285

我见过一些使用模板模板参数（即以模板作为参数的模板）进行基于策略的类设计的 C++ 示例。这种技术还有什么其他用途？

4

10 回答 10

236

我认为您需要使用模板模板语法来传递一个参数，其类型是一个依赖于另一个模板的模板，如下所示：

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有两个模板参数，类型和分配器，所以我们必须接受它们。幸运的是，由于类型推导，我们不需要显式写出确切的类型。

您可以像这样使用它：

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

这就是我更喜欢编写这种类型的代码的方式。

于 2008-10-17T20:51:02.213 回答
179

实际上，模板模板参数的用例是相当明显的。一旦您了解到 C++ stdlib 存在未为标准容器类型定义流输出运算符的巨大漏洞，您将继续编写如下内容：

template<typename T>
static inline std::ostream& operator<<(std::ostream& out, std::list<T> const& v)
{
    out << '[';
    if (!v.empty()) {
        for (typename std::list<T>::const_iterator i = v.begin(); ;) {
            out << *i;
            if (++i == v.end())
                break;
            out << ", ";
        }
    }
    out << ']';
    return out;
}

然后你会发现 vector 的代码是一样的，因为 forward_list 是一样的，实际上，即使对于多种地图类型，它仍然是一样的。这些模板类除了元接口/协议之外没有任何共同点，并且使用模板模板参数可以捕获所有它们的共性。不过，在继续编写模板之前，有必要检查参考以回忆序列容器接受 2 个模板参数 - 用于值类型和分配器。虽然分配器是默认的，但我们仍然应该在模板操作符<< 中说明它的存在：

template<template <typename, typename> class Container, class V, class A>
std::ostream& operator<<(std::ostream& out, Container<V, A> const& v)
...

瞧，这将自动适用于所有当前和未来遵循标准协议的序列容器。要将地图添加到组合中，需要查看参考以注意它们接受 4 个模板参数，因此我们需要另一个版本的 operator<< 上面带有 4-arg 模板模板参数。我们还会看到 std:pair 尝试使用 2-arg operator<< 来呈现我们之前定义的序列类型，因此我们将为 std::pair 提供专门化。

顺便说一句，使用允许可变参数模板的 C+11（因此应该允许可变参数模板模板参数），可以使用单个 operator<< 来统治它们。例如：

#include <iostream>
#include <vector>
#include <deque>
#include <list>

template<typename T, template<class,class...> class C, class... Args>
std::ostream& operator <<(std::ostream& os, const C<T,Args...>& objs)
{
    os << __PRETTY_FUNCTION__ << '\n';
    for (auto const& obj : objs)
        os << obj << ' ';
    return os;
}

int main()
{
    std::vector<float> vf { 1.1, 2.2, 3.3, 4.4 };
    std::cout << vf << '\n';

    std::list<char> lc { 'a', 'b', 'c', 'd' };
    std::cout << lc << '\n';

    std::deque<int> di { 1, 2, 3, 4 };
    std::cout << di << '\n';

    return 0;
}

输出

std::ostream &operator<<(std::ostream &, const C<T, Args...> &) [T = float, C = vector, Args = <std::__1::allocator<float>>]
1.1 2.2 3.3 4.4 
std::ostream &operator<<(std::ostream &, const C<T, Args...> &) [T = char, C = list, Args = <std::__1::allocator<char>>]
a b c d 
std::ostream &operator<<(std::ostream &, const C<T, Args...> &) [T = int, C = deque, Args = <std::__1::allocator<int>>]
1 2 3 4
于 2013-01-14T02:44:19.563 回答
74

下面是取自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;
于 2008-10-18T11:03:51.510 回答
21

这是我的CUDA 卷积神经网络库中的另一个实际示例。我有以下类模板：

template <class T> class Tensor

这实际上是实现 n 维矩阵操作。还有一个子类模板：

template <class T> class TensorGPU : public Tensor<T>

它实现了相同的功能，但在 GPU 中。这两个模板都可以使用所有基本类型，例如 float、double、int 等。我还有一个类模板（简化版）：

template <template <class> class TT, class T> class CLayerT: public Layer<TT<T> >
{
    TT<T> weights;
    TT<T> inputs;
    TT<int> connection_matrix;
}

这里有模板模板语法的原因是因为我可以声明类的实现

class CLayerCuda: public CLayerT<TensorGPU, float>

它将在 GPU 上同时具有浮点类型的权重和输入，但 connection_matrix 将始终为 int，无论是在 CPU 上（通过指定 TT = Tensor）还是在 GPU 上（通过指定 TT=TensorGPU）。

于 2011-07-17T19:13:15.827 回答
12

假设您正在使用 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;

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

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

上面的 typedef 不起作用，因为您不能 typedef 到未指定的模板。但是，这可行（并且 C++11 对模板类型定义具有本机支持）：

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，除非我还没有学到另一个技巧。

于 2012-10-09T18:47:52.477 回答
10

这就是我遇到的：

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();
}
于 2014-05-29T10:17:45.507 回答
5

这是我刚刚使用的东西的概括。我发布它是因为它是一个非常简单的示例，它演示了一个实际用例以及默认参数：

#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;
};
于 2015-05-19T23:13:57.500 回答
4

在 pfalcon 提供的具有可变参数模板的解决方案中，由于可变参数专业化的贪婪特性，我发现实际上很难将 ostream 运算符专门用于 std::map。这是一个对我有用的轻微修改：

#include <iostream>
#include <vector>
#include <deque>
#include <list>
#include <map>

namespace containerdisplay
{
  template<typename T, template<class,class...> class C, class... Args>
  std::ostream& operator <<(std::ostream& os, const C<T,Args...>& objs)
  {
    std::cout << __PRETTY_FUNCTION__ << '\n';
    for (auto const& obj : objs)
      os << obj << ' ';
    return os;
  }  
}

template< typename K, typename V>
std::ostream& operator << ( std::ostream& os, 
                const std::map< K, V > & objs )
{  

  std::cout << __PRETTY_FUNCTION__ << '\n';
  for( auto& obj : objs )
  {    
    os << obj.first << ": " << obj.second << std::endl;
  }

  return os;
}


int main()
{

  {
    using namespace containerdisplay;
    std::vector<float> vf { 1.1, 2.2, 3.3, 4.4 };
    std::cout << vf << '\n';

    std::list<char> lc { 'a', 'b', 'c', 'd' };
    std::cout << lc << '\n';

    std::deque<int> di { 1, 2, 3, 4 };
    std::cout << di << '\n';
  }

  std::map< std::string, std::string > m1 
  {
      { "foo", "bar" },
      { "baz", "boo" }
  };

  std::cout << m1 << std::endl;

    return 0;
}
于 2015-02-19T01:52:44.753 回答
2

它提高了代码的可读性，提供了额外的类型安全性并节省了一些编译器工作。

假设你想打印一个容器的每个元素，你可以使用下面的代码没有模板模板参数

template <typename T> void print_container(const T& c)
{
    for (const auto& v : c)
    {
        std::cout << v << ' ';
    }
    std::cout << '\n';
}

或使用模板模板参数

template< template<typename, typename> class ContainerType, typename ValueType, typename AllocType>
void print_container(const ContainerType<ValueType, AllocType>& c)
{
    for (const auto& v : c)
    {
        std::cout << v << ' ';
    }
    std::cout << '\n';
}

假设你传入一个整数 say print_container(3)。对于前一种情况，模板将由编译器实例化，编译器会抱怨c在 for 循环中的使用，后者根本不会实例化模板，因为找不到匹配的类型。

一般来说，如果你的模板类/函数是设计用来处理模板类作为模板参数的，最好说清楚。

于 2017-08-30T18:35:21.500 回答
2

我将它用于版本化类型。

如果您有一个通过模板版本化的类型，例如MyType<version>，您可以编写一个函数来捕获版本号：

template<template<uint8_t> T, uint8_t Version>
Foo(const T<Version>& obj)
{
    assert(Version > 2 && "Versions older than 2 are no longer handled");
    ...
    switch (Version)
    {
    ...
    }
}

因此，您可以根据传入的类型的版本做不同的事情，而不是为每种类型都重载。您还可以具有以通用方式接收MyType<Version>和返回的转换函数MyType<Version+1>，甚至递归它们以具有ToNewest()从任何旧版本返回类型的最新版本的函数（对于可能已经存储一段时间的日志非常有用但需要用今天最新的工具处理）。

于 2019-09-29T17:27:04.700 回答