Question

我想知道是否可以编写一个模板函数，该函数可以将任何其他任意模板作为参数并正确匹配模板名称（即不仅仅是结果类）。我所知道的工作是：

template<template<typename ...> class TemplateT, typename... TemplateP>
void f(const TemplateT<TemplateP...>& param);

例如，f(std::vector<int>())或f(std::list<int>())匹配但不适用于f(std::array<int, 3>())，因为第二个参数是size_t且没有类型。

现在我想我可以做一些疯狂的事情：

template<template<typename ...> class TemplateT, size... Sizes, typename... TemplateP>
void f(const TemplateT<Sizes..., TemplateP...>& param);

希望编译器能够正确地导出TemplateP省略号或Sizes省略号为空。但它不仅难看，而且还适用于采用任何类型或size_t参数的模板。它仍然不会匹配任意模板，例如bool参数。

重载方法也是如此：

template<template<typename ...> class TemplateT, typename... TemplateP>
void f(const TemplateT<TemplateP...>& param);

template<template<typename ...> class TemplateT, size... Sizes>
void f(const TemplateT<Sizes...>& param);

此外，如果我们想要混合size_t和typenames，这种方法就无法奏效。那么匹配任何东西所需的东西就是这样的东西，对省略号中允许的内容没有任何限制：

template<template<...> class TemplateT, ... Anything>
void f(const TemplateT<Anything...>& param);

该语法不起作用，但也许还有其他语法来定义这样的东西？

这主要是我想知道该语言有什么可能，认为它可能实际上有用，如果你有不同的模板，其中第一个参数总是被修复，你想根据返回类型更改它保留其他一切。像这样：

template<
    template<typename ValueT, ...> class TemplateT,
    ... Anything,
    typename ValueT,
    typename ResultT = decltype(some_operation_on_value_t(std::declval<ValueT>())>
TemplateT<ResultT, Anything...> f(const TemplateT<ValueT, Anything...>& in);

那么，使用模式匹配以任何方式使这项工作完全通用吗？

这不仅仅是一个思想实验，因为我遇到的用例就是创建在容器上运行的纯函数原语，并隐式构造不可变的结果容器。如果结果容器具有不同的数据类型，我们需要知道容器操作的类型，因此对任何容器的唯一要求是模板的第一个参数需要是输入类型，因此可以用不同的替换结果中的输出类型，但代码应该忽略之后的任何模板参数，并且不应该关心它是类型还是值。

Answer 1

你感兴趣的构造有两个可变参数模板。

外部可变参数模板参数列表TemplateP＆amp; 功能模板

Sizes

内部参数包作为模板模板参数TemplateT的模板参数，类模板

首先，让我们看看内部TemplateT类：为什么省略号运算符与TemplateT< int, 2 >之类的东西不匹配？那么，该标准将§14.5.3中的可变参数模板定义为

template<class ... Types> struct Tuple { };
template<T ...Values> struct Tuple2 { };

其中第一种情况下的模板参数包可以仅匹配类型，而第二种版本仅类型T的值。特别是，

Tuple < 0 >    error;  // error, 0 is not a type!
Tuple < T, 0 > error2; // T is a type, but zero is not!
Tuple2< T >    error3; // error, T is not a value
Tuple2< T, 0 > error4; // error, T is not a value

都是畸形的。此外，不可能回到像

这样的东西

template<class ... Types, size_t ...Sizes> struct Tuple { };

因为§14.1.11中的标准状态：

如果主类模板或别名模板的模板参数是模板参数包，则为应该是最后一个模板参数。不应遵循功能模板的模板参数包除非可以从parameter-type-list推导出该模板参数，否则使用另一个模板参数函数模板或具有默认参数（14.8.2）。

换句话说，对于类模板，定义中只能出现一个可变参数包。因此，上述（双） - 变量类定义是错误的。因为内部阶级总是需要这样的组合，所以不可能像你想象的那样写出一般内容。

什么可以获救？对于外部函数模板，可以将一些分片放在一起，但您不会喜欢它。只要可以从第一个参数包推导出第二个参数包，就可以出现两个参数包（在函数模板中）。因此，诸如

之类的功能

template < typename... Args, size_t... N > void g(const std::array< Args, N > &...arr);
g(std::array< double, 3 >(), std::array< int, 5>());

允许

，因为可以推导出整数值。当然，这必须专门针对每种容器类型，并且远非您想象的那样。

Answer 2

您必须具有重新绑定容器类型的元函数。因为您不能只替换第一个模板参数：

vector<int, allocator<int> > input;
vector<double, allocator<int> > just_replaced;
vector<double, allocator<double> > properly_rebound;

所以，只需为已知的容器集写一个这样的元函数。

template<class Container, class NewValue> class rebinder;

// example for vectors with standard allocator
template<class V, class T> class rebinder< std::vector<V>, T > {
public:
  typedef std::vector<T> type;
};
// example for lists with arbitrary allocator
template<class V, class A, class T> class rebinder< std::list<V,A>, T > {
  typedef typename A::template rebind<T>::other AT; // rebind the allocator
public:
  typedef std::list<T,AT> type; // rebind the list
};
// example for arrays
template<class V, size_t N> class rebinder< std::array<V,N>, T > {
public:
  typedef std::array<T,N> type;
};

不同容器的重新绑定规则可能会有所不同。

另外，您可能需要一个从任意容器中提取值类型的元函数，而不仅仅是std-conformant（typedef *unspecified* value_type）

template<class Container> class get_value_type {
public:
  typedef typename Container::value_type type; // common implementation
};
template<class X> class get_value_type< YourTrickyContainer<X> > {
  ......
public:
  typedef YZ type;
};

Answer 3

如果我们有这样的东西会很棒，因为它可以让我们轻而易举地写出is_same_template特征。
在那之前，我们一直专注。

与任何类型的参数匹配的C ++可变参数模板模板参数

3 个答案: