访问模板类A中的X和Y，如模板<template <int X，int Y> class> class A;

Question

在另一个模板类中使用模板类参数的模板参数的正确语法是什么？

例如：如何访问Foo类中的Param的X和Y？

计划：

template < template < int, int > class X1> 
struct Foo { 
int foo() { 
printf("ok%d %d\n", X1::X, X1::Y); 
return 0; 
}}; 

template < int X, int Y > 
class Param { 
int x,y; 
public: 
Param(){x=X; y=Y;} 
void printParam(){ 
cout<<x<<" "<<y<<"\n"; 
} 
}; 

int main() { 
Param<10, 20> p; 
p.printParam(); 
Foo<Param> tt; 
tt.foo(); 
return 0; 
} 

这样上面的代码，为printf语句编译器抱怨：

In member function 'int Foo<X1>::foo()': 
Line 4: error: 'template<int <anonymous>, int <anonymous> > class X1' used without template parameters 
compilation terminated due to -Wfatal-errors. 

Answer 1

你不能。模板模板参数表示您在不提供模板参数的情况下采用模板名称。

Foo<Param> tt; 

在这里您可以看到没有数值提供给Param。你需要一个模板模板参数，以便Foo本身可以用它喜欢的任何参数实例化Params。

例子：

template < template < int, int > class X1> 
struct Foo { 

    X1<1, 2> member; 

    X1<42, 100> foo(); 
}; 

template <int N, int P> struct A {}; 

template <int X, int Y> struct B {}; 

Foo<A> a_foo; //has a member of type A<1, 2>, foo returns A<42, 100> 
Foo<B> b_foo; //has a member of type B<1, 2>, foo returns B<42, 100> 

---

但是，如果你希望你的Foo输出这些整数，它必须采取真正的类型，而不是模板。其次，模板参数的名称（X和Y）只在范围内有意义。它们完全是任意的标识符。你可以用简单的元编程检索值：

#include <cstdio> 

template <class T> 
struct GetArguments; 

//partial specialization to retrieve the int parameters of a T<int, int> 
template <template <int, int> class T, int A, int B> 
struct GetArguments<T<A, B> > 
{ 
    enum {a = A, b = B}; 
}; 
//this specialization also illustrates another use of template template parameters: 
//it is used to pick out types that are templates with two int arguments 

template <class X1> 
struct Foo { 
    int foo() { 
    printf("ok%d %d\n", GetArguments<X1>::a, GetArguments<X1>::b); 
    return 0; 
    } 
}; 

template < int X, int Y > 
class Param { 
public: 
    void print(); 
}; 

//this is to illustrate X and Y are not essential part of the Param template 
//in this method definition I have chosen to call them something else 
template <int First, int Second> 
void Param<First, Second>::print() 
{ 
    printf("Param<%d, %d>\n", First, Second); 
} 

int main() { 

    Foo< Param<10, 20> > tt; 
    tt.foo(); 
    Param<10, 20> p; 
    p.print(); 
    return 0; 
} 

Answer 2

你不能把模板类参数的模板参数，因为参数是不带参数的模板。你可以这样做，而不是：

template < typename X1 > 
struct Foo; 

template < template < int, int > class X1, int A, int B > 
struct Foo< X1< A, B > > 
{ 
    ... here you can use A and B directly, or X1< A, B >::X and X1< A, B >::Y ... 
}; 

您指定模板采取单一类型，并专注它采用两个int参数的模板的情况下。有了这个定义，你可以使用这样的：

Foo< Param< 0, 1 > > tt; 

Answer 3

这这里是可以工作，以及一个例子：

template < typename X1> 
struct Foo; 

template < template < int, int > class X1, int X, int Y > 
struct Foo< X1<X,Y> > { 
    int foo() { 
     printf("ok%d %d\n", X, Y); 
     return 0; 
    } 
}; 

template < int X, int Y > 
class Param { 
    int x,y; 
public: 
    Param(){x=X; y=Y;} 
    void printParam(){ 
     cout<<x<<" "<<y<<"\n"; 
    } 
}; 

int main() { 
    Param<10, 20> p; 
    p.printParam(); 
    Foo< Param<30,40> > tt; 
    tt.foo(); 
    return 0; 
}