Inherit template class with nested class

Question

I want to create a class B that inherits from template class A. And I want the B's nested class E to be the template parameter in this inheritance. More visually:

template <class T>
class A {
}

class B : public A<B::E> {
    class E {
        int x;
    }
}

class C : public A<C::E> {
    class E {
        int x;
        int y;
    }
}

I think the problem is that the compiler doesn't know that the class B will have a nested class E by the time it's processing the declaration of B, since I'm getting the error:

no member named 'E' in 'B'

I've seen this similar question, but I would like to confirm that there's no direct solution to this conflict before giving up with this approach.

Thanks!

Possible duplicate of [Forward declaration of nested types/classes in C++](https://stackoverflow.com/questions/951234/forward-declaration-of-nested-types-classes-in-c) — Henri Menke, Jul 26 '18 at 23:59
You would need a forward declaration of `B::E` but that is currently not possible in C++. — Henri Menke, Jul 27 '18 at 00:00

score 3 · Answer 1 · answered Jul 27 '18 at 00:05

The closest thing I can think of is to use a base class.

template <class T>
class A {
};

class B; // forward declaration of ::B
namespace detail { 
class B { 
    friend class ::B;
    class E {
        int x;
    };
};
} /* namespace detail */

class B : public A<detail::B::E> {
};

score 3 · Accepted Answer · edited Jul 27 '18 at 04:38

I don't think it can be done directly.

One obvious approach would be something like defining B::E and C::E in some other namespace (to at least keep them out of the global namespace), then use them inside of the "parent" classes:

template <class T>
class A { /* ... */ };

namespace B_detail {
    class E { /* … */ };
}

class B : public A<B_detail::E> { /* ... */ };

namespace C_detail {
    class E { /* ... */ };
}

class C : public A<C_detail::E> { /* ... */ };

Depending upon the situation, there's a decent chance you'd also need/want to declare *_detail::E a friend of B/C.

score 0 · Answer 3 · answered Jul 27 '18 at 00:27

As other have said, you cannot do a forward declaration of a nested class.

So you can use put your nested class inside a namespace instead. Or alternatively, you could just remove any nesting but then you would have to provide distinct names.

Here is one example that demonstrate both ways. And if you don't need forward declaration the code could be even a bit simpler.

#include <memory>

template <class T>
class A {
public:
    A();

    // Demonstrate a possible way that T could be used.
    std::unique_ptr<T> t;
};

template <class T>
A<T>::A() : t(std::make_unique<T>())
{
}

// Using a forward declared (top level) class...
class B : public A<class BE> {
};

class BE {
public:
    int x;
};

// Using a forward declared class inside a namespace...
namespace C_details
{
    class E;
}

class C : public A<C_details::E> {
};

namespace C_details
{
    class E {
    public:
        int x;
        int y;
    };
}


int main()
{
    B b;
    b.t->x = 3;

    C c;
    c.t->y = 4;

    return 0;
}

Inherit template class with nested class

3 Answers3

Linked