CRTP: why a difference between getting a nested type and nested method of the derived class?

Question

The base class in the CRTP pattern can access the member functions of the derived class, but it can't access a nested type in the derived class.

Why this difference?

To illustrate, consider the following piece of code:

template<typename Derived>
struct crtp_base
{
    void crtp_method() { return static_cast<Derived&>(*this).method(); } // compiles

    using crtp_type = typename Derived::type; // doesn't compile
};

struct X : public crtp_base<X>
{
    void method() {}

    using type = int;
};

int main()
{

}

crtp_type causes a compilation error, while crtp_method compiles fine, although both attempt to access something defined in the Derived class. What is the C++ specification that explains that difference?

error: no type named 'type' in 'X'. Here is the [full program](http://coliru.stacked-crooked.com/a/fc8c236719fd755a). — Jonathan Boccara, Jul 27 '18 at 10:41
Why do you use `static_cast<>`? Just calling `this->method();` compiles fine (gcc 6.3.0, clang 3.8) — Adrian W, Jul 27 '18 at 10:51
@AdrianW Could you please send across a compiling code snippet? — Jonathan Boccara, Jul 27 '18 at 10:56
It's because it doesn't call the function, but it stops from compiling when it instantiates it: https://godbolt.org/g/nKPwgm — Jonathan Boccara, Jul 27 '18 at 16:26
Ah, got it, thank you. `method()` is only declared in the derived class and therefore will not be known in the base class `crtp_base`. Declaring as abstract virtual virtual method in `crtp_base` fixes the problem. This is IMHO stll better than `static_cast`. Updated example here: https://godbolt.org/g/VVwuD9 — Adrian W, Jul 28 '18 at 13:46

score 8 · Accepted Answer · answered Jul 27 '18 at 08:13

The difference here is that instantiation of method happens only when you actually use it while instantiation of crtp_base happens at public crtp_base<X> where type X is still incomplete. The workaround would be to use type traits:

template<typename x_Target>
struct Trait;

template<typename Derived>
struct crtp_base
{
    void crtp_method() { return static_cast<Derived&>(*this).method(); }

    using crtp_type = typename Trait<Derived>::type;
};

struct X;

template<>
struct Trait<X>
{
    using type = int;
};

struct X : public crtp_base<X>
{
    void method() {}

    using type = Trait<X>::type;
};

CRTP: why a difference between getting a nested type and nested method of the derived class?

1 Answers1

Linked