我想知道是否可以编写一个模板函数,可以将任何其他任意模板作为参数并正确匹配模板名称(即不仅仅是结果类).我所知道的工作是:
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);
该语法不起作用,但也许还有其他语法来定义这样的东西？ …
假设我有一个模板(称为ExampleTemplate),它带有两个参数:容器类型(例如list,vector)和包含的类型(例如float,bool等).由于容器实际上是模板,因此该模板具有模板参数.这是我必须写的:
#include <vector>
#include <list>
using namespace std;
template < template <class,class> class C, typename T>
class ExampleTemplate {
C<T,allocator<T> > items;
public:
....
};
main()
{
ExampleTemplate<list,int> a;
ExampleTemplate<vector,float> b;
}
你可能会问什么是"分配器"的事情.好吧,最初,我尝试了显而易见的事情......
template < template <class> class C, typename T>
class ExampleTemplate {
C<T> items;
};
...但遗憾的是我发现了分配器的默认参数......
vector<T, Alloc>
list<T, Alloc>
etc
...必须在模板声明中明确地"保留".正如您所看到的,这会使代码变得更加丑陋,并迫使我重现模板参数的默认值(在本例中为分配器).
哪个是坏的.
编辑:问题不是关于容器的具体问题 - 它是关于"模板参数模板中的默认值",以上只是一个例子.答案取决于STL容器具有":: value_type"的知识不是我所追求的.想想一般问题:如果我需要在模板ExampleTemplate中使用模板参数C,那么在ExampleTemplate的主体中,我是否必须在使用它时重现C的默认参数？如果必须,那不会引入不必要的重复和其他问题(在这种情况下,C是STL容器,可移植性问题 - 例如"allocator")？
每个allocator类必须具有类似于以下内容的接口:
template<class T>
class allocator
{
...
template<class Other>
struct rebind { typedef allocator<Other> other; };
};
使用分配器的类做了多余的事情:
template<class T, class Alloc = std::allocator<T> >
class vector { ... };
但为什么这有必要呢？
换句话说,他们不能只是说:
template<class T>
class allocator { ... };
template<class T, template<class> class Alloc = std::allocator>
class vector { ... };
哪个更优雅,更少冗余,(在某些类似的情况下)可能更安全？
他们为什么要走这rebind条路,这也会造成更多的冗余(即你要说T两次)？
(类似的问题char_traits和其他问题......尽管它们并非都有rebind,但它们仍然可以从模板模板参数中受益.)
但是,如果您需要多于1个模板参数,这将无效!
实际上,它运作得很好!
template<unsigned int PoolSize>
struct pool
{
template<class T>
struct allocator
{
T pool[PoolSize];
... …我想问一下下面的代码示例是否应该编译:
#include <iostream>
#include <vector>
#include <typeinfo>
using namespace std;
template <template <class...> class C>
struct convert_container
{
using type = C<double>;
// Visual Studio requires this to be:
// using type = C<double, std::allocator<doble>>
};
int main()
{
std::cout << typeid(convert_container<std::vector>::type).name();
}
代码可以使用GCC 4.8.1和Clang 3.4编译,但不适用于Visual Studio 2013.我得到的错误:
error C2976: 'std::vector' : too few template arguments
c:\program files (x86)\microsoft visual studio 12.0\vc\include\vector(650) : see declaration of 'std::vector'
c:\users\micha?\documents\visual studio 2013\projects\transform\transform.cpp(14) : see reference to class template instantiation 'convert_container<std::vector>' being compiled …我有以下模板.
template<typename T, typename U>
std::vector<U> map(const std::vector<T> &v, std::function<U(const T&)> f) {
std::vector<U> res;
res.reserve(v.size());
std::transform(std::begin(v), std::end(v), std::end(res), f);
return res;
}
当我在我的代码中使用它时,我指定了模板参数.为什么编译器无法为我推断出这个？如何更改模板定义以使其工作？
vector<int> numbers = { 1, 3, 5 };
// vector<string> strings = map(numbers, [] (int x) { return string(x,'X'); });
vector<string> strings = map<int, string>(numbers, [] (int x) { return string(x,'X'); });
可运行代码:http://ideone.com/FjGnxd
这个问题中的原始代码来自:std :: transform-like函数返回转换后的容器
我试图T从一个类型中推断出底层模板类型E = T<T2,T3>.这将使例如可以制作模板函数pair_maker(const E&a),其可以与几种类似类型的容器中的一种一起使用.粗糙的元代码:
template <typename T>
auto pairmaker(const E & a) -> PairContents<E,std::string>::type {
ContainerPairMaker<E,std::string>::type output;
... some code ...
return output;
}
PairContents<E,std::string>
将类型vector<int>转换为vector<pair(int,std::string)>或whatever<T1>转换为whatever<pair(T1,std::string)>.
类型剖析的另一个类似示例是std :: array(或类似的容器),我想在其中找出容器类型来创建一个新的类似数组.例如,对于这些类型的功能(这是现在的实际工作代码)
template <typename T >
auto make_some3(const T & a)
-> std::array<typename T::value_type,10*std::tuple_size<T>::value>{
return std::array<typename T::value_type,10*std::tuple_size<T>::value>{} ;
}
这工作正常,但我所追求的是自动显式使用'std :: array'.
对于std :: array,有tuple_size特性有帮助,类似的东西可以用于查找type任何第二个参数,但我再也想不出任何用于查找容器类型的东西.
总结一下:什么样的机器(如果有的话)可以用于这样的情况.在多大程度上可以处理模板参数,模板模板参数,任意数量的参数和未知类型的非模板参数的混合.