与任何types的参数匹配的C ++ variadic模板模板参数

我想知道是否有可能写一个模板函数,可以采取任何其他任意模板作为参数,并正确匹配模板名称(即不只是结果类)。 我所知道的工作是这样的:

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而没有types。

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

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

希望编译器能正确地派生TemplateP省略号或Sizes省略号为空。 但是,这不仅丑陋,而且还适用于采用type或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_ttypenames ,这种方法不会工作。 那么匹配任何东西需要的东西就是这样的,在省略号中允许的地方没有任何限制:

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

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

这主要是我想知道什么是可能的语言,认为实际上可能有一个使用它,如果你有不同的模板,其中第一个参数总是固定的,你想改变它的基础上的返回types,并保持一切。 像这样的东西:

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

那么,有什么办法可以使用模式匹配以完全通用的方式来完成这个工作?

这不是一个纯粹的思想实验,因为这个被卡住的用例就是创build纯粹的函数原语,这些原语在容器上运行,并且会隐式地构造不可变的结果容器。 如果结果容器具有不同的数据types,我们需要知道容器操作的types,所以对于任何容器的唯一要求是模板的第一个参数需要是inputtypes,因此可以用不同的输出types的结果,但是代码应该忽略任何后面的模板参数,不应该在乎它是一个types还是一个值。

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

  • 函数模板的外部可变参数模板参数列表TemplatePSizes
  • 一个内部参数包作为模板参数模板参数TemplateT ,一个类模板

首先,让我们来看看TemplateT内部类:为什么省略号运算符不能匹配类似TemplateT< int, 2 > ? 那么,这个标准在§14.5.3中定义了可变参数模板

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

其中第一种情况下的模板参数包只能匹配types,而在第二种情况下只能Ttypes的值。 尤其是,

 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中的标准状态:

如果主类模板或别名模板的模板参数是模板参数包,则它应该是最后一个模板参数。 除非模板参数可以从函数模板的参数types列表中推导出来,或者具有缺省参数(14.8.2),否则函数模板的模板参数包不应该跟随其他模板参数。

换句话说,对于类模板,只有一个可变参数包可能出现在定义中。 因此,上面的(双) – variables类定义是畸形的。 因为内部阶层总是需要这样的组合,所以不可能写出像你所想的一般的东西。


什么可以拯救? 对于外部函数模板,一些碎片可以放在一起,但是你不会喜欢它。 只要可以从第一个参数包中推导出第二个参数包,则可以出现两个参数包(在function模板中)。 所以,一个函数如

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

是允许的,因为可以推导出整数值。 当然,这必须专门针对每一种容器types,而且与您想象的远不一样。

您必须具有重新绑定容器types的元函数。 因为你不能只replace第一个模板参数:

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

重新绑定的规则可能因不同的容器而异。

你也可能需要一个从任意容器中提取值types的元函数,而不仅仅是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; }; 

如果我们有这样的东西,这将是非常棒的,因为它可以让我们is_same_template地编写一个is_same_template特性。
在此之前,我们一路专精。