可变参数模板类参数容器实例化
Variadic template class argument containers instantiation
我想实例化一个可变参数模板类Store<TArgs...>
,该类TArgs...
包中的每个类型都有一个std::vector
。
template<typename... TArgs> class Store {
// obviously not valid code
// assuming each type of TArgs... has a `unsigned int` id that can be
// retrieved with getId<T>()
std::array<sizeof...(TArgs), std::vector<TArgs...>> bags;
template<typename T> void add(T mValue) {
bags[getId<T>()].push_back(mValue);
}
template<typename T> std::vector<T>& get() {
return bags[getId<T>()];
}
};
假设我有一个Store<int, float, double>
.我显然知道,在编译时,它将能够存储int
,float
和double
值。
我可以使用模板专业化:
template<> class Store<int, float, double> {
std::vector<int> vi;
std::vector<float> vf;
std::vector<double> vd;
template<typename T> void add(T);
template<> void add<int>(int mValue) { vi.push_back(mValue); }
template<> void add<float>(float mValue) { vf.push_back(mValue); }
template<> void add<double>(double mValue) { vd.push_back(mValue); }
// ...
};
。但这需要手写每种可能的类型组合,并且不适用于用户定义的类型。
我相信编译器知道使用可变参数模板生成像Store<int, float, double>
这样的类所需的一切 - 有没有办法实际表达这种意图?
以下内容应该可以满足您的需求:
#include <type_traits>
#include <vector>
#include <tuple>
#include <iostream>
// indices are a classic
template< std::size_t... Ns >
struct indices
{
using next = indices< Ns..., sizeof...( Ns ) >;
};
template< std::size_t N >
struct make_indices
{
using type = typename make_indices< N - 1 >::type::next;
};
template<>
struct make_indices< 0 >
{
using type = indices<>;
};
// we need something to find a type's index within a list of types
template<typename T, typename U, std::size_t=0>
struct index {};
template<typename T, typename... Us, std::size_t N>
struct index<T,std::tuple<T,Us...>,N>
: std::integral_constant<std::size_t, N> {};
template<typename T, typename U, typename... Us, std::size_t N>
struct index<T,std::tuple<U,Us...>,N>
: index<T,std::tuple<Us...>,N+1> {};
// we need a way to remove duplicate types from a list of types
template<typename T,typename I=void> struct unique;
// step 1: generate indices
template<typename... Ts>
struct unique< std::tuple<Ts...>, void >
: unique< std::tuple<Ts...>, typename make_indices<sizeof...(Ts)>::type >
{
};
// step 2: remove duplicates. Note: No recursion here!
template<typename... Ts, std::size_t... Is>
struct unique< std::tuple<Ts...>, indices<Is...> >
{
using type = decltype( std::tuple_cat( std::declval<
typename std::conditional<index<Ts,std::tuple<Ts...>>::value==Is,std::tuple<Ts>,std::tuple<>>::type
>()... ) );
};
// a helper to turn Ts... into std::vector<Ts>...
template<typename> struct vectorize;
template<typename... Ts>
struct vectorize<std::tuple<Ts...>>
{
using type = std::tuple< std::vector<Ts>... >;
};
// now you can easily use it to define your Store
template<typename... Ts> class Store
{
using Storage = typename vectorize<typename unique<std::tuple<Ts...>>::type>::type;
Storage storage;
template<typename T>
decltype(std::get<index<T,typename unique<std::tuple<Ts...>>::type>::value>(storage))
slot()
{
return std::get<index<T,typename unique<std::tuple<Ts...>>::type>::value>(storage);
}
public:
template<typename T> void add(T mValue) {
slot<T>().push_back(mValue);
}
template<typename T> std::vector<T>& get() {
return slot<T>();
}
};
int main()
{
Store<int,int,double,int,double> store;
store.add(42);
store.add(3.1415);
store.add(21);
std::cout << store.get<int>().size() << std::endl;
std::cout << store.get<double>().size() << std::endl;
}
现场示例(无注释)
在 C++14 中,std::tuple
的元素可以按类型访问,前提是没有多个相同类型的元素。因此,您应该能够这样编写它:
template<typename... TArgs>
struct Store {
std::tuple<std::vector<TArgs>...> bags;
template<typename T>
void add(T mValue) {
get<T>().push_back(mValue);
}
template<typename T>
std::vector<T>& get() {
return std::get<std::vector<T>>(bags);
}
};
相关文章:
- 在 c++ 中的模板实例化中使用带有构造函数的类作为类型参数
- 如果模板参数是另一个模板的实例化,则键入特征测试
- 如何在模板函数中实例化其长度使用模板参数的数组
- 函数在可变参数模板的实例化期间不可见
- 实例化模板时,我是否必须显式显示参数包中的类型?
- 从模板参数包实例化的访问类实现
- C++ 可变参数模板实例化深度超过最大值 900
- 与参数匹配的友元模板函数实例化
- 有没有办法根据命令行参数定义数组大小?运行时与编译时实例化?
- 在编译时检查未实例化的类模板是否继承自其第一个模板参数
- 如何将包装作为模板参数实例化专用模板类
- 如何在 c++ 中使用枚举参数实例化对象
- 使用NULL参数实例化模板类
- 使用模板参数实例化模板类
- 使用bool非类型参数实例化类模板时出错
- 从类别上防止或阻止使用特定参数实例化对象
- 如何用不同的参数实例化类
- 模板是否为相同类型的参数实例化多次
- C++:根据一个参数实例化一个模板化的类
- 用Constructor参数实例化类对象和不带参数C++的*运算符之间的区别