How to derive from a nested class of a variadic template argument?

Question

Given the following two structs, one could derive from both nested 'Nested' classes, and call foo() and bar() from the derived object:

struct WithNested1 {
    template<class T> struct Nested {
        void foo();
    };
};

struct WithNested2 {
    template<class T> struct Nested {
        void bar();
    };
};

struct Test : WithNested1::Nested<Test>,
              WithNested2::Nested<Test>
{

};

Test test;
test.foo();
test.bar();

But, if both of the outer classes were passed as variadic template arguments, how would you derive from them?

For example, this fails to compile:

template<typename... Ts>
struct Test : Ts::template Nested<Test>...
{

};

Test<WithNested1, WithNested2> test;
test.foo();
test.bar();

error: 'foo' : is not a member of 'Test'
error: 'bar' : is not a member of 'Test'

strangely, it compiles if the calls to foo() and bar() are removed.

aaronman · Accepted Answer · 2013-11-10T04:29:19.833

template <typename... Ts>                                                          
struct Test : Ts::template Nested<Test<Ts...>>...                                  
{                                                                                  

};

This is the same answer as above but I figured I'd explain how it works. First in your example Test has no template param (which the compiler should warn you of), but which should we give it. The point of CRTP is to give the class you inherit from a template param that is the same as your type, that way it has access to your methods and members through the of the template param. Your type in this case is Test<Ts...> so that is what you have to pass it. As @aschepler already pointed out normally you could use Test by itself but it's not in scope until your already inside the class.

I think this is a cleaner way of doing what you want.

template <typename T>                                                              
struct A {                                                                         
    void bar (){                                                                   
        static_cast<T*>(this)->val = 3;                                            
    }                                                                              
};                                                                                 

template <typename T>                                                              
struct B {                                                                         
    void foo (){                                                                   
        static_cast<T*>(this)->val = 90;                                           
    }                                                                              
};                                                                                 


template <template<class> class ... Ts>                                            
struct Test : Ts<Test<Ts...>>...                                                   
{                                                                                  
    int val;                                                                       
};                                                                                 

int main() {                                                                       
    Test<A,B> test;                                                                
    test.foo();                                                                    
    test.bar();                                                                    
    return 0;                                                                      
}

Hey, thanks for this! The second half of your post is actually the ONLY thing that works for me. I tried using Test in visual studio and mingw, and neither one will take it. Also, I didn't know you could pass a template without it's <>s. — CuriousGeorge, Nov 10 '13 at 05:48
@bitwise visual studio is sometimes behind on c++11 features, as for the template without <> readup on template template parameters — aaronman, Nov 10 '13 at 05:49

Evgeny Panasyuk · Answer 2 · 2013-11-10T04:19:02.493

This works:

template<typename... Ts>
struct Test : Ts::template Nested<Test<Ts...>>...
//                                    ^^^^^^^
{
};

9/2:

[...]. The class-name is also inserted into the scope of the class itself; this is known as the injected-class-name. For purposes of access checking, the injected-class-name is treated as if it were a public member name. [...]

14.6.1/1:

Like normal (non-template) classes, class templates have an injected-class-name (Clause 9). The injectedclass-name can be used as a template-name or a type-name. When it is used with a template-argument-list, as a template-argument for a template template-parameter, or as the final identifier in the elaborated-typespecifier of a friend class template declaration, it refers to the class template itself. Otherwise, it is equivalent to the template-name followed by the template-parameters of the class template enclosed in <>.

score 2 · Answer 3 · answered Nov 10 '13 at 04:10

2

The "injected class name" Test which can be used as an abbreviation of Test<Ts...> is not in scope where you tried to use Nested<Test>, since the class scope does not begin until the { token.

Use

template<typename... Ts>
struct Test : public Ts::template Nested<Test<Ts...>>...
{
};

answered Nov 10 '13 at 04:10

aschepler

70,891
9
107
161

I like this explanation the best, because it's unintuitive that `Test` wouldn't work without the params, although a good compiler just tells you that it needs template params – aaronman Nov 10 '13 at 04:17

How to derive from a nested class of a variadic template argument?

3 Answers3