如何在不使用额外模板参数的情况下使用模板模板参数声明/定义类

Question

考虑以下使用模板模板参数...

#include <iostream>

template <typename X>
class A
{
    X _t;
public:
    A(X t)
        :_t(t)
    {
    }
    X GetValue()
    {
        return _t;
    }
};

template <typename T, template <typename T> class C >
class B
{
    C<T> _c;
public:
    B(T t)
        :_c(t)
    {
    }
    T GetValue()
    {
        return _c.GetValue();
    }
};

using namespace std;

int main()
{
    B<int, A> b(10);
    cout<<b.GetValue();
    return 0;
}

有没有什么方法可以去掉模板参数T？例如有没有办法使以下工作？

//Does not compile
template <template <typename T> class C >
class B
{
    C _c;
public:
    B(T t)
        :_c(t)
    {
    }
    T GetValue()
    {
        return _c.GetValue();
    }
};

int main()
{
    B< A<int> > b(10);
    cout<<b.GetValue();
    return 0;
}

Answer 1

我假设您在代码中关注 X 和 A。

通常的模式是有

template<typename C>
struct B
{
   C c;
};

然后，在符合替换条件的类内部：

template<typename X>
class A
{
   typedef X type_name;
   X t;
};

然后你可以使用C::type_name访问模板参数。

Answer 2

这是不可能的。请注意，这是一个常见的误解：A<int> 不再是类模板！所以它不适合模板模板参数，但必须使用类型参数来接受：

template<typename C>
struct B {
    C c;
};

B< A<int> > b;

你使用单独参数的方式没问题。

如果您想接受A<int> 但又想将其重新绑定到另一个参数，您可以使用此模式，标准分配器也使用此模式：

template<typename T>
struct A {
    template<typename U>
    struct rebind {
        typedef A<U> type;
    };
};

template<typename C>
struct B {
    typename C::template rebind<float>::type c;
};

B< A<int> > b;

现在，B< A<int> >::c 的类型为 A<float>。 C:: 之前的 typename 告诉编译器末尾的 ::type 是类型而不是静态非类型成员。 C:: 之后的 template 告诉编译器 rebind<float> 是模板实例化，而不是比较。

Answer 3

有什么问题：

template <typename C >
struct B
{
    C c;
};

int main()
{
    B< A<int> > b;
    return 0;
}

Answer 4

您可以嵌套参数。也就是说，参数的值本身可以被参数化。

template <typename X>
struct A
{
  X t;
};

template <typename  C>
struct B
{
  C c;
};

int main()
{
  B< A<int> > b;
  return 0;
}

在此示例中，main() 中的 b 声明使用 int 作为参数创建了 A 的特化，然后使用 A<int> 作为参数创建了 B 的特化。因此，在B 的特化中，C 是A<int>。