c++ - 如何从可变模板参数的嵌套类派生？

Question

给定以下两个结构，可以从两个嵌套的“嵌套”类派生，并从派生对象调用 foo() 和 bar():

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();

但是，如果两个外部类都作为可变模板参数传递，您将如何派生它们？

例如，编译失败:

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'

奇怪的是，如果删除对 foo() 和 bar() 的调用，它会编译。

Answer 1

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

};  

这与上面的答案相同，但我想我会解释它是如何工作的。首先在你的例子中 Test没有模板参数(编译器应该警告你)，但我们应该给它。 CRTP 的要点是为您从模板参数继承的类提供与您的类型相同的模板参数，这样它就可以通过模板参数访问您的方法和成员。在这种情况下，您的类型是 Test<Ts...>所以这就是你必须通过的。正如@aschepler 通常已经指出的那样，您可以使用 Test本身，但在您已经进入类之前，它不在范围内。

我认为这是一种更简洁的方式来做你想做的事。

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;                                                                      
}