No member named in class: Both paths of the if else statement should be compilable at compile time

I'm writing a cache model using C++. The model consists of some level of caches (the Cache class) and a main memory (the Memory class). A Cache is backed by either another Cache or a Memory. For example:

Cache l1 ---backed by---> Cache l2 ---backed by---> Memory memory

When l1.readFromCache() is called, if l1 is backed by another Cache (l2 for example), it will call l2.readFromCache(), otherwise, l2.readFromMemory() is called. In the above diagram, this sequence is expected:

l1.readFromCache() calls l2.readFromCache(), then l2.readFromCache() calls memory.readFromMemory()

Here is the code:

#include <iostream>

class Memory
{
public:
    unsigned long readFromMemory(unsigned long address)
    {
        (void)address;
        std::cout << "readFromMemory() from Memory" << std::endl;
        return 100;
    }
};

template <class T>
class Cache
{
public:
    Cache(const std::string& name, T* cache, bool exclusive, bool writeback) :
        name{ name }, backedByCache{ true }, cache{ cache }, exclusive{ exclusive }, writeback{ writeback }, memory{} {}

    Cache(const std::string& name, Memory* memory) :
        name{ name }, backedByCache{ false }, cache{}, exclusive{ false }, writeback{ false }, memory{ memory } {}

    unsigned long readFromCache(unsigned long address)
    {
        std::cout << "readFromCache() from Cache " << name << std::endl;
        if (backedByCache) {
            std::cout << name << " is backed by a cache" << std::endl;
            return cache->readFromCache(address); /**** ERRORRRRRRR ****/
        }
        else {
            std::cout << name << " is backed by a memory" << std::endl;
            return memory->readFromMemory(address);
        }
        return 100;
    }

private:
    const std::string name;
    const bool backedByCache;
    T* cache;
    bool exclusive;
    bool writeback;
    Memory* memory;
};

int main()
{
    Memory memory;

    using L2Cache = Cache<Memory>;
    L2Cache l2{ "L2", &memory };

    using L1Cache = Cache<L2Cache>;
    L1Cache l1{ "L1", &l2, true, true };

    l1.readFromCache(0x80000000);

    return 0;
}

When I execute the code above, both g++ (11.3.1) and clang++ (16.0.6) throw the same error at line return cache->readFromCache(address);

main.cc:29:39: error: no member named 'readFromCache' in 'Memory'
return cache->readFromCache(address);
~~~~~  ^
main.cc:29:39: note: in instantiation of member function 'Cache<Memory>::readFromCache' requested here
main.cc:56:12: note: in instantiation of member function 'Cache<Cache<Memory>>::readFromCache' requested here
l1.readFromCache(0x80000000);

The templated class Cache has two constructors, one accepts a pointer T to another Cache and two booleans, the other one accepts a pointer to the Memory class. There is a boolean data member (backedByCache) to track if the cache is backed by a cache or a memory. By this way, I can expand the model to more levels easily. I expect to see these lines when I run that program:

readFromCache() from Cache L1
L1 is backed by a cache
readFromCache() from Cache L2
L2 is backed by a memory
readFromMemory() from Memory

I don't know why compiler complain about readFromCache() not in Memory since if (backedByCache) should choose the appropriate read method from the appropriate pointer. I have tried with shared_ptr and unique_ptr but the issue still the same.

Can anyone help me explain what was wrong and correct me if any.

Thank you very much.

The Problem:

backedByCache determines the execution of either the if (true path) or the else (false path) block in runtime, but both paths must be compiled.
Therefore even if backedByCache is false the compiler attempts to compile the if true path and issues the error you get.

A Solution:

C++17 offers if constexpr, which instructs the compiler to compile only one of the paths, depending on the condition.
However in this case the condition must be a compile time constant, and therefore a member (even a const one) cannot be used.

Instead you can use a bool template parameter:

//-----------------vvvvvvvvvvvvvvvvvv-
template <class T, bool backedByCache>
class Cache
{
public:
// ...
unsigned long readFromCache(unsigned long address)
{
std::cout << "readFromCache() from Cache " << name << std::endl;
//-vvvvvvvvv----------------
if constexpr (backedByCache) 
{
std::cout << name << " is backed by a cache" << std::endl;
return cache->readFromCache(address); /**** ERRORRRRRRR ****/
}
else 
{
std::cout << name << " is backed by a memory" << std::endl;
return memory->readFromMemory(address);
}
return 100;
}
}

Creating an object requires an additional template argument, e.g.:

//----------------------------vvvvv--
using L2Cache = Cache<Memory, false>;
L2Cache l2{ "L2", &memory };

Full demo (Godbolt)