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

Answer 3

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

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;

访问模板类A中的X和Y，如模板<template <int x，=“”int =“”y =“”> class＆gt; A类; </template <int>

3 个答案: