这是我遇到的情况:

template<class A>
class B
{
  A& a;
};

template<class B>
class A
{
  B b;
};

class AInstance : A<B<A<B<A<B<A<B<... (oh oh)>>>>>>>>
{

};

可解为:

template<class A>
class B
{
  A& a;
};

template< template<class> class B>
class A
{
  B<A> b;
};

class AInstance : A<B> //happy
{

};

或者(工作代码):

template<class A>
class B
{
public:
    A* a;
    int GetInt() { return a->dummy; }
};

template< template<class> class B>
class A
{
public:
    A() : dummy(3) { b.a = this; }
    B<A> b;
    int dummy;
};

class AInstance : public A<B> //happy
{
public:
    void Print() { std::cout << b.GetInt(); }
};

int main()
{
    std::cout << "hello";
    AInstance test;
    test.Print();
}

这是我用过的东西推广出来的。我发布它是因为它是一个非常简单的例子，它演示了一个实际的用例以及默认参数:

#include <vector>

template <class T> class Alloc final { /*...*/ };

template <template <class T> class allocator=Alloc> class MyClass final {
  public:
    std::vector<short,allocator<short>> field0;
    std::vector<float,allocator<float>> field1;
};

假设您正在使用CRTP为一组子模板提供一个“接口”;父类和子类在其他模板参数中都是参数:

template <typename DERIVED, typename VALUE> class interface {
    void do_something(VALUE v) {
        static_cast<DERIVED*>(this)->do_something(v);
    }
};

template <typename VALUE> class derived : public interface<derived, VALUE> {
    void do_something(VALUE v) { ... }
};

typedef interface<derived<int>, int> derived_t;

注意'int'的重复，这实际上是指定给两个模板的相同类型参数。你可以为DERIVED使用模板模板来避免重复:

template <template <typename> class DERIVED, typename VALUE> class interface {
    void do_something(VALUE v) {
        static_cast<DERIVED<VALUE>*>(this)->do_something(v);
    }
};

template <typename VALUE> class derived : public interface<derived, VALUE> {
    void do_something(VALUE v) { ... }
};

typedef interface<derived, int> derived_t;

请注意，您取消了直接向派生模板提供其他模板参数;“接口”仍然接收它们。

这还允许您在依赖于类型参数的“接口”中构建类型defs，可以从派生的模板中访问。

上面的typedef不起作用，因为你不能对一个未指定的模板进行typedef。然而，这是可行的(c++ 11对模板类型defs有原生支持):

template <typename VALUE>
struct derived_interface_type {
    typedef typename interface<derived, VALUE> type;
};

typedef typename derived_interface_type<int>::type derived_t;

不幸的是，派生模板的每个实例化都需要一个derived_interface_type，除非我还没有学到其他技巧。

我认为你需要使用模板模板语法来传递一个参数，它的类型是依赖于另一个模板的模板，就像这样:

template <template<class> class H, class S>
void f(const H<S> &value) {
}

这里H是一个模板，但我想让这个函数处理H的所有特化。

注意:我已经编程c++很多年了，只需要一次。我发现这是一个很少需要的功能(当然，当你需要它的时候，它很方便!)

我一直在努力想一些好的例子，老实说，大多数时候这是不必要的，但让我们想出一个例子。让我们假设std::vector没有typedef value_type类型。

那么如何编写一个函数来为向量元素创建正确类型的变量呢?这是可行的。

template <template<class, class> class V, class T, class A>
void f(V<T, A> &v) {
    // This can be "typename V<T, A>::value_type",
    // but we are pretending we don't have it

    T temp = v.back();
    v.pop_back();
    // Do some work on temp

    std::cout << temp << std::endl;
}

注意:std::vector有两个模板形参，type和allocator，所以我们必须同时接受它们。幸运的是，由于类型演绎，我们不需要显式地写出确切的类型。

你可以这样用:

f<std::vector, int>(v); // v is of type std::vector<int> using any allocator

或者更好的是，我们可以用:

f(v); // everything is deduced, f can deal with a vector of any type!

更新:即使是这个人为的例子，虽然是说明性的，但由于c++11引入了auto，它不再是一个令人惊讶的例子。现在同样的函数可以写成:

template <class Cont>
void f(Cont &v) {

    auto temp = v.back();
    v.pop_back();
    // Do some work on temp

    std::cout << temp << std::endl;
}

这就是我喜欢写这类代码的方式。

这是我遇到的情况:

template<class A>
class B
{
  A& a;
};

template<class B>
class A
{
  B b;
};

class AInstance : A<B<A<B<A<B<A<B<... (oh oh)>>>>>>>>
{

};

可解为:

template<class A>
class B
{
  A& a;
};

template< template<class> class B>
class A
{
  B<A> b;
};

class AInstance : A<B> //happy
{

};

或者(工作代码):

template<class A>
class B
{
public:
    A* a;
    int GetInt() { return a->dummy; }
};

template< template<class> class B>
class A
{
public:
    A() : dummy(3) { b.a = this; }
    B<A> b;
    int dummy;
};

class AInstance : public A<B> //happy
{
public:
    void Print() { std::cout << b.GetInt(); }
};

int main()
{
    std::cout << "hello";
    AInstance test;
    test.Print();
}

下面是一个简单的例子，摘自Andrei Alexandrescu的《现代c++设计-泛型编程和设计模式的应用》:

他使用一个带有模板参数的类来实现策略模式:

// Library code
template <template <class> class CreationPolicy>
class WidgetManager : public CreationPolicy<Widget>
{
   ...
};

他解释说: 通常，宿主类已经知道，或者可以很容易地推断出策略类的模板参数。在上面的例子中，WidgetManager总是管理Widget类型的对象，因此要求用户在CreationPolicy的实例化中再次指定Widget是多余的，而且有潜在的危险。在这种情况下，库代码可以使用模板模板参数来指定策略。

结果是客户端代码可以以一种更优雅的方式使用'WidgetManager':

typedef WidgetManager<MyCreationPolicy> MyWidgetMgr;

而不是更麻烦，更容易出错的方式，一个定义缺乏模板模板参数将需要:

typedef WidgetManager< MyCreationPolicy<Widget> > MyWidgetMgr;