C++11模版元编程
1.概述
模版元编程(template metaprogram)是C++中最复杂也是威力最强大的编程范式,它是一种可以创建和操纵程序的程序。模版元编程完全不同于普通的运行期程序,它很独特,因为模版元程序的执行完全是在编译期,并且模版元程序操纵的数据不能是运行时变量,只能是编译期常量,不可修改,另外它用到的语法元素也是相当有限,不能使用运行期的一些语法,比如if-else,for等语句都不能用。因此,模版元编程需要很多技巧,常常需要类型重定义、枚举常量、继承、模板偏特化等方法来配合,因此编写模版元编程比较复杂也比较困难。
现在C++11新增了一些模版元相关的特性,不仅可以让我们编写模版元程序变得更容易,还进一步增强了泛型编程的能力,比如type_traits让我们不必再重复发明轮子了,给我们提供了大量便利的元函数,还提供了可变模板参数和tuple,让模版元编程“如虎添翼”。本文将向读者展示C++11中模版元编程常用的技巧和具体应用。
2.模版元基本概念
模版元程序由元数据和元函数组成,元数据就是元编程可以操作的数据,即C++编译器在编译期可以操作的数据。元数据不是运行期变量,只能是编译期常量,不能修改,常见的元数据有enum枚举常量、静态常量、基本类型和自定义类型等。
元函数是模板元编程中用于操作处理元数据的“构件”,可以在编译期被“调用”,因为它的功能和形式和运行时的函数类似,而被称为元函数,它是元编程中最重要的构件。元函数实际上表现为C++的一个类、模板类或模板函数,它的通常形式如下:
template<int N, int M>
struct meta_func
{
static const int value = N+M;
}
调用元函数获取value值:cout<<meta_func<1, 2>::value<<endl;
meta_func的执行过程是在编译期完成的,实际执行程序时,是没有计算动作而是直接使用编译期的计算结果的。元函数只处理元数据,元数据是编译期常量和类型,所以下面的代码是编译不过的:
int i = , j = ;
meta_func<i, j>::value; //错误,元函数无法处理运行时普通数据
模板元编程产生的源程序是在编译期执行的程序,因此它首先要遵循C++和模板的语法,但是它操作的对象不是运行时普通的变量,因此不能使用运行时的C++关键字(如if、else、for),可用的语法元素相当有限,最常用的是:
- enum、static const,用来定义编译期的整数常量;
- typedef/using,用于定义元数据;
- T、Args...,声明元数据类型;
- template,主要用于定义元函数;
- "::",域运算符,用于解析类型作用域获取计算结果(元数据)。
如果模板元编程中需要if-else、for等逻辑时该怎么办呢?
模板元中的if-else可以通过type_traits来实现,它不仅仅可以在编译期做判断,还可以做计算、查询、转换和选择。
模板元中的for等逻辑可以通过递归、重载、和模板特化(偏特化)等方法实现。
下面来看看C++11提供的模版元基础库type_traits。
3.type_traits
type_traits是C++11提供的模板元基础库,通过type_traits可以实现在编译期计算、查询、判断、转换和选择,提供了模板元编程需要的一些常用元函数。下面来看看一些基本的type_traits的基本用法。
最简单的一个type_traits是定义编译期常量的元函数integral_constant,它的定义如下:
template< class T, T v >
struct integral_constant;
借助这个简单的trait,我们可以很方便地定义编译期常量,比如定义一个值为1的int常量可以这样定义:
using one_type = std::integral_constant<int, >;
或者
template<class T>
struct one_type : std::integral_constant<int, >{};
获取常量则通过one_type::value来获取,这种定义编译期常量的方式相比C++98/03要简单,在C++98/03中定义编译期常量一般是这样定义的:
template<class T>
struct one_type
{
enum{value = };
}; template<class T>
struct one_type
{
static const int value = ;
};
可以看到,通过C++11的type_traits提供的一个简单的integral_constant就可以很方便的定义编译期常量,而无需再去通过定义enum和static const变量方式去定义编译期常量了,这也为定义编译期常量提供了另外一种方法。C++11的type_traits已经提供了编译期的true和false,是通过integral_constant来定义的:
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
除了这些基本的元函数之外,type_traits还提供了丰富的元函数,比如用于编译期判断的元函数:
这只是列举一小部分的type_traits元函数,type_traits提供了上百个方便的元函数,读者可以参考http://en.cppreference.com/w/cpp/header/type_traits,这些基本的元函数用法比较简单:
#include <iostream>
#include <type_traits> int main() {
std::cout << "int: " << std::is_const<int>::value << std::endl;
std::cout << "const int: " << std::is_const<const int>::value << std::endl; //判断类型是否相同
std::cout<< std::is_same<int, int>::value<<"\n";// true
std::cout<< std::is_same<int, unsignedint>::value<<"\n";// false //添加、移除const
cout << std::is_same<const int, add_const<int>::type>::value << endl;
cout << std::is_same<int, remove_const<const int>::type>::value << endl; //添加引用
cout << std::is_same<int&, add_lvalue_reference<int>::type>::value << endl;
cout << std::is_same<int&&, add_rvalue_reference<int>::type>::value << endl; //取公共类型
typedef std::common_type<unsigned char, short, int>::type NumericType;
cout << std::is_same<int, NumericType>::value << endl; return ;
}
type_traits还提供了编译期选择traits:std::conditional,它在编译期根据一个判断式选择两个类型中的一个,和条件表达式的语义类似,类似于一个三元表达式。它的原型是:
template< bool B, class T, class F >
struct conditional;
用法比较简单:
#include <iostream>
#include <type_traits> int main()
{
typedef std::conditional<true,int,float>::type A; // int
typedef std::conditional<false,int,float>::type B; // float typedef std::conditional<(sizeof(long long) >sizeof(long double)),
long long, long double>::type max_size_t; cout<<typeid(max_size_t).name()<<endl; //long double
}
另外一个常用的type_traits是std::decay(朽化),它对于普通类型来说std::decay(朽化)是移除引用和cv符,大大简化了我们的书写。除了普通类型之外,std::decay还可以用于数组和函数,具体的转换规则是这样的:
先移除T类型的引用,得到类型U,U定义为remove_reference<T>::type。
- 如果is_array<U>::value为 true,修改类型type为remove_extent<U>::type *。
- 否则,如果is_function<U>::value为 true,修改类型type将为add_pointer<U>::type。
- 否则,修改类型type为 remove_cv<U>::type。
std::decay的基本用法:
typedef std::decay<int>::type A; // int
typedef std::decay<int&>::type B; // int
typedef std::decay<int&&>::type C; // int
typedef std::decay<constint&>::type D; // int
typedef std::decay<int[]>::type E; // int*
typedef std::decay<int(int)>::type F; // int(*)(int)
std::decay除了移除普通类型的cv符的作用之外,还可以将函数类型转换为函数指针类型,从而将函数指针变量保存起来,以便在后面延迟执行,比如下面的例子。
template<typename F>
struct SimpFunction
{
using FnType = typename std::decay<F>::type;//先移除引用再添加指针 SimpFunction(F& f) : m_fn(f){} void Run()
{
m_fn();
} FnType m_fn;
};
如果要保存输入的函数,则先要获取函数对应的函数指针类型,这时就可以用std::decay来获取函数指针类型了,using FnType = typename std::decay<F>::type;实现函数指针类型的定义。type_traits还提供了获取可调用对象返回类型的元函数:std::result_of,它的基本用法:
int fn(int) {return int();} // function
typedef int(&fn_ref)(int); // function reference
typedef int(*fn_ptr)(int); // function pointer
struct fn_class { int operator()(int i){return i;} }; // function-like class int main() {
typedef std::result_of<decltype(fn)&(int)>::type A; // int
typedef std::result_of<fn_ref(int)>::type B; // int
typedef std::result_of<fn_ptr(int)>::type C; // int
typedef std::result_of<fn_class(int)>::type D; // int
}
type_traits还提供了一个很有用的元函数std::enable_if,它利用SFINAE(substitude failure is not an error)特性,根据条件选择重载函数的元函数std::enable_if,它的原型是:
template<bool B, class T = void> struct enable_if;
根据enable_if的字面意思就可以知道,它使得函数在判断条件B仅仅为true时才有效,它的基本用法:
template <class T>
typename std::enable_if<std::is_arithmetic<T>::value, T>::type foo(T t)
{
return t;
}
auto r = foo(); //返回整数1
auto r1 = foo(1.2); //返回浮点数1.2
auto r2 = foo(“test”); //compile error
在上面的例子中对模板参数T做了限定,即只能是arithmetic(整型和浮点型)类型,如果为非arithmetic类型,则编译不通过,因为std::enable_if只对满足判断式条件的函数有效,对其他函数无效。
可以通过enable_if来实现编译期的if-else逻辑,比如下面的例子通过enable_if和条件判断式来将入参分为两大类,从而满足所有的入参类型:
template <class T>
typename std::enable_if<std::is_arithmetic<T>::value, int>::type foo1(T t)
{
cout << t << endl;
return ;
} template <class T>
typename std::enable_if<!std::is_arithmetic<T>::value, int>::type foo1(T &t)
{
cout << typeid(T).name() << endl;
return ;
}
对于arithmetic类型的入参则返回0,对于非arithmetic的类型则返回1,通过arithmetic将所有的入参类型分成了两大类进行处理。从上面的例子还可以看到,std::enable_if可以实现强大的重载机制,因为通常必须是参数不同才能重载,如果只有返回值不同是不能重载的,而在上面的例子中,返回类型相同的函数都可以重载。
C++11的type_traits提供了近百个在编译期计算、查询、判断、转换和选择的元函数,为我们编写元程序提供了很大的便利。如果说C++11的type_traits让模版元编程变得简单,那么C++11提供的可变模板参数和tuple则进一步增强了模板元编程。
4.可变模板参数
C++11的可变模版参数(variadic templates)是C++11新增的最强大的特性之一,它对参数进行了高度泛化,它能表示0到任意个数、任意类型的参数。关于它的用法和使用技巧读者可以参考笔者在程序员2015年2月A上的文章:泛化之美--C++11可变模版参数的妙用,这里不再赘述,这里将要展示的如何借助可变模板参数实现一些编译期算法,比如获取最大值、判断是否包含了某个类型、根据索引查找类型、获取类型的索引和遍历类型等算法。实现这些算法需要结合type_traits或其它C++11特性,下面来看看这些编译期算法是如何实现的。
编译期从一个整形序列中获取最大值:
//获取最大的整数
template <size_t arg, size_t... rest>
struct IntegerMax; template <size_t arg>
struct IntegerMax<arg> : std::integral_constant<size_t, arg>
{
}; template <size_t arg1, size_t arg2, size_t... rest>
struct IntegerMax<arg1, arg2, rest...> : std::integral_constant<size_t, arg1 >= arg2 ? IntegerMax<arg1, rest...>::value :
IntegerMax<arg2, rest...>::value >
{
};
这个IntegerMax的实现用到了type_traits中的std::integral_const,它在展开参数包的过程中,不断的比较,直到所有的参数都比较完,最终std::integral_const的value值即为最大值。它的使用很简单:
cout << IntegerMax<2, 5, 1, 7, 3>::value << endl; //value为7
我们可以在IntegerMax的基础上轻松的实现获取最大内存对齐值的元函数MaxAlign。
编译期获取最大的align:
template<typename... Args>
struct MaxAlign : std::integral_constant<int, IntegerMax<std::alignment_of<Args>::value...>::value>{};
cout << MaxAlign<int, short, double, char>::value << endl; //value为8
编译判断是否包含了某种类型:
template < typename T, typename... List >
struct Contains; template < typename T, typename Head, typename... Rest >
struct Contains<T, Head, Rest...>
: std::conditional< std::is_same<T, Head>::value, std::true_type, Contains<T, Rest... >> ::type{}; template < typename T >
struct Contains<T> : std::false_type{};
用法:cout<<Contains<int, char, double, int, short>::value<<endl; //输出true
这个Contains的实现用到了type_traits的std::conditional、std::is_same、std::true_type和std::false_type,它的实现思路是在展开参数包的过程中不断的比较类型是否相同,如果相同则设置值为true,否则设置为false。
编译期获取类型的索引:
template < typename T, typename... List >
struct IndexOf; template < typename T, typename Head, typename... Rest >
struct IndexOf<T, Head, Rest...>
{
enum{ value = IndexOf<T, Rest...>::value+ };
}; template < typename T, typename... Rest >
struct IndexOf<T, T, Rest...>
{
enum{ value = };
}; template < typename T >
struct IndexOf<T>
{
enum{value = -};
};
用法:cout<< IndexOf<int, double, short, char, int, float>::value<<endl; //输出3
这个IndexOf的实现比较简单,在展开参数包的过程中看是否匹配到特化的IndexOf<T, T, Rest...>,如果匹配上则终止递归将之前的value累加起来得到目标类型的索引位置,否则将value加1,如果所有的类型中都没有对应的类型则返回-1;
编译期根据索引位置查找类型:
template<int index, typename... Types>
struct At; template<int index, typename First, typename... Types>
struct At<index, First, Types...>
{
using type = typename At<index - , Types...>::type;
}; template<typename T, typename... Types>
struct At<, T, Types...>
{
using type = T;
};
用法:
using T = At<, int, double, char>::type;
cout << typeid(T).name() << endl; //输出double
At的实现比较简单,只要在展开参数包的过程中,不断的将索引递减至0时为止即可获取对应索引位置的类型。接下来看看如何在编译期遍历类型。
template<typename T>
void printarg()
{
cout << typeid(T).name() << endl;
} template<typename... Args>
void for_each()
{
std::initializer_list<int>{(printarg<Args>(), )...};
}
用法:for_each<int,double>();//将输出int double
这里for_each的实现是通过初始化列表和逗号表达式来遍历可变模板参数的。
可以看到,借助可变模板参数和type_traits以及模板偏特化和递归等方式我们可以实现一些有用的编译期算法,这些算法为我们编写应用层级别的代码奠定了基础,后面模板元编程的具体应用中将会用到这些元函数。
C++11提供的tuple让我们编写模版元程序变得更灵活了,在一定程度上增强了C++的泛型编程能力,下面来看看tuple如何应用于元程序中的。
5.tuple与模版元
C++11的tuple本身就是一个可变模板参数组成的元函数,它的原型如下:
template<class...Types>
class tuple;
tuple在模版元编程中的一个应用场景是将可变模板参数保存起来,因为可变模板参数不能直接作为变量保存起来,需要借助tuple保存起来,保存之后再在需要的时候通过一些手段将tuple又转换为可变模板参数,这个过程有点类似于化学中的“氧化还原反应”。看看下面的例子中,可变模板参数和tuple是如何相互转换的:
//定义整形序列
template<int...>
struct IndexSeq{}; //生成整形序列
template<int N, int... Indexes>
struct MakeIndexes : MakeIndexes<N - , N - , Indexes...>{}; template<int... indexes>
struct MakeIndexes<, indexes...>{
typedef IndexSeq<indexes...> type;
}; template<typename... Args>
void printargs(Args... args){
//先将可变模板参数保存到tuple中
print_helper(typename MakeIndexes<sizeof... (Args)>::type(), std::make_tuple(args...));
} template<int... Indexes, typename... Args>
void print_helper(IndexSeq<Indexes...>, std::tuple<Args...>&& tup){
//再将tuple转换为可变模板参数,将参数还原回来,再调用print
print(std::get<Indexes>(tup)...);
}
template<typename T>
void print(T t)
{
cout << t << endl;
} template<typename T, typename... Args>
void print(T t, Args... args)
{
print(t);
print(args...);
}
用法:printargs(1, 2.5, “test”); //将输出1 2.5 test
上面的例子print实际上是输出可变模板参数的内容,具体做法是先将可变模板参数保存到tuple中,然后再通过元函数MakeIndexes生成一个整形序列,这个整形序列就是IndexSeq<0,1,2>,整形序列代表了tuple中元素的索引,生成整形序列之后再调用print_helper,在print_helper中展开这个整形序列,展开的过程中根据具体的索引从tuple中获取对应的元素,最终将从tuple中取出来的元素组成一个可变模板参数,从而实现了tuple“还原”为可变模板参数,最终调用print打印可变模板参数。
tuple在模板元编程中的另外一个应用场景是用来实现一些编译期算法,比如常见的遍历、查找和合并等算法,实现的思路和可变模板参数实现的编译期算法类似,关于tuple相关的算法,读者可以参考笔者在github上的代码:https://github.com/qicosmos/cosmos/tree/master/tuple。
下面来看看模版元的具体应用。
6.模版元的应用
我们将展示如何通过模版元来实现function_traits和Vairant类型。
function_traits用来获取函数语义的可调用对象的一些属性,比如函数类型、返回类型、函数指针类型和参数类型等。下面来看看如何实现function_traits。
template<typename T>
struct function_traits; //普通函数
template<typename Ret, typename... Args>
struct function_traits<Ret(Args...)>
{
public:
enum { arity = sizeof...(Args) };
typedef Ret function_type(Args...);
typedef Ret return_type;
using stl_function_type = std::function<function_type>;
typedef Ret(*pointer)(Args...); template<size_t I>
struct args
{
static_assert(I < arity, "index is out of range, index must less than sizeof Args");
using type = typename std::tuple_element<I, std::tuple<Args...>>::type;
};
}; //函数指针
template<typename Ret, typename... Args>
struct function_traits<Ret(*)(Args...)> : function_traits<Ret(Args...)>{}; //std::function
template <typename Ret, typename... Args>
struct function_traits<std::function<Ret(Args...)>> : function_traits<Ret(Args...)>{}; //member function
#define FUNCTION_TRAITS(...) \
template <typename ReturnType, typename ClassType, typename... Args>\
struct function_traits<ReturnType(ClassType::*)(Args...) __VA_ARGS__> : function_traits<ReturnType(Args...)>{}; \ FUNCTION_TRAITS()
FUNCTION_TRAITS(const)
FUNCTION_TRAITS(volatile)
FUNCTION_TRAITS(const volatile) //函数对象
template<typename Callable>
struct function_traits : function_traits<decltype(&Callable::operator())>{};
由于可调用对象可能是普通的函数、函数指针、lambda、std::function和成员函数,所以我们需要针对这些类型分别做偏特化。其中,成员函数的偏特化稍微复杂一点,因为涉及到cv符的处理,这里通过定义一个宏来消除重复的模板类定义。参数类型的获取我们是借助于tuple,将参数转换为tuple类型,然后根据索引来获取对应类型。它的用法比较简单:
template<typename T>
void PrintType()
{
cout << typeid(T).name() << endl;
}
int main()
{
std::function<int(int)> f = [](int a){return a; };
PrintType<function_traits<std::function<int(int)>>::function_type>(); //将输出int __cdecl(int)
PrintType<function_traits<std::function<int(int)>>::args<>::type>();//将输出int
PrintType<function_traits<decltype(f)>::function_type>();//将输出int __cdecl(int)
}
有了这个function_traits和前面实现的一些元函数,我们就能方便的实现一个“万能类型”—Variant,Variant实际上一个泛化的类型,这个Variant和boost.variant的用法类似。boost.variant的基本用法如下:
typedef variant<int,char, double> vt;
vt v = ;
v = 'a';
v = 12.32;
这个variant可以接受已经定义的那些类型,看起来有点类似于c#和java中的object类型,实际上variant是擦除了类型,要获取它的实际类型的时候就稍显麻烦,需要通过boost.visitor来访问:
struct VariantVisitor : public boost::static_visitor<void>
{
void operator() (int a)
{
cout << "int" << endl;
} void operator() (short val)
{
cout << "short" << endl;
} void operator() (double val)
{
cout << "double" << endl;
} void operator() (std::string val)
{
cout << "string" << endl;
}
}; boost::variant<int,short,double,std::string> v = ;
boost::apply_visitor(visitor, v); //将输出int
通过C++11模版元实现的Variant将改进值的获取,将获取实际值的方式改为内置的,即通过下面的方式来访问:
typedef Variant<int, double, string, int> cv;
cv v = ;
v.Visit([&](double i){cout << i << endl; }, [](short i){cout << i << endl; }, [=](int i){cout << i << endl; },[](const string& i){cout << i << endl; });//结果将输出10
这种方式更方便直观。Variant的实现需要借助前文中实现的一些元函数MaxInteger、MaxAlign、Contains和At等等。下面来看看Variant实现的关键代码,完整的代码请读者参考笔者在github上的代码https://github.com/qicosmos/cosmos/blob/master/Varaint.hpp。
template<typename... Types>
class Variant{
enum{
data_size = IntegerMax<sizeof(Types)...>::value,
align_size = MaxAlign<Types...>::value
};
using data_t = typename std::aligned_storage<data_size, align_size>::type;
public:
template<int index>
using IndexType = typename At<index, Types...>::type; Variant(void) :m_typeIndex(typeid(void)){}
~Variant(){ Destroy(m_typeIndex, &m_data); } Variant(Variant<Types...>&& old) : m_typeIndex(old.m_typeIndex){
Move(old.m_typeIndex, &old.m_data, &m_data);
} Variant(const Variant<Types...>& old) : m_typeIndex(old.m_typeIndex){
Copy(old.m_typeIndex, &old.m_data, &m_data);
} template <class T,
class = typename std::enable_if<Contains<typename std::remove_reference<T>::type, Types...>::value>::type> Variant(T&& value) : m_typeIndex(typeid(void)){
Destroy(m_typeIndex, &m_data);
typedef typename std::remove_reference<T>::type U;
new(&m_data) U(std::forward<T>(value));
m_typeIndex = type_index(typeid(U));
} template<typename T>
bool Is() const{
return (m_typeIndex == type_index(typeid(T)));
} template<typename T>
typename std::decay<T>::type& Get(){
using U = typename std::decay<T>::type;
if (!Is<U>())
{
cout << typeid(U).name() << " is not defined. " << "current type is " <<
m_typeIndex.name() << endl;
throw std::bad_cast();
} return *(U*)(&m_data);
} template<typename F>
void Visit(F&& f){
using T = typename Function_Traits<F>::template arg<>::type;
if (Is<T>())
f(Get<T>());
} template<typename F, typename... Rest>
void Visit(F&& f, Rest&&... rest){
using T = typename Function_Traits<F>::template arg<>::type;
if (Is<T>())
Visit(std::forward<F>(f));
else
Visit(std::forward<Rest>(rest)...);
}
private:
void Destroy(const type_index& index, void * buf){
std::initializer_list<int>{(Destroy0<Types>(index, buf), )...};
} template<typename T>
void Destroy0(const type_index& id, void* data){
if (id == type_index(typeid(T)))
reinterpret_cast<T*>(data)->~T();
} void Move(const type_index& old_t, void* old_v, void* new_v) {
std::initializer_list<int>{(Move0<Types>(old_t, old_v, new_v), )...};
} template<typename T>
void Move0(const type_index& old_t, void* old_v, void* new_v){
if (old_t == type_index(typeid(T)))
new (new_v)T(std::move(*reinterpret_cast<T*>(old_v)));
} void Copy(const type_index& old_t, void* old_v, void* new_v){
std::initializer_list<int>{(Copy0<Types>(old_t, old_v, new_v), )...};
} template<typename T>
void Copy0(const type_index& old_t, void* old_v, void* new_v){
if (old_t == type_index(typeid(T)))
new (new_v)T(*reinterpret_cast<const T*>(old_v));
}
private:
data_t m_data;
std::type_index m_typeIndex;//类型ID
};
实现Variant首先需要定义一个足够大的缓冲区用来存放不同的类型的值,这个缓类型冲区实际上就是用来擦除类型,不同的类型都通过placement new在这个缓冲区上创建对象,因为类型长度不同,所以需要考虑内存对齐,C++11刚好提供了内存对齐的缓冲区aligned_storage:
template< std::size_t Len, std::size_t Align = /*default-alignment*/ >
struct aligned_storage;
它的第一个参数是缓冲区的长度,第二个参数是缓冲区内存对齐的大小,由于Varaint可以接受多种类型,所以我们需要获取最大的类型长度,保证缓冲区足够大,然后还要获取最大的内存对齐大小,这里我们通过前面实现的MaxInteger和MaxAlign就可以了,Varaint中内存对齐的缓冲区定义如下:
enum
{
data_size = IntegerMax<sizeof(Types)...>::value,
align_size = MaxAlign<Types...>::value
};
using data_t = typename std::aligned_storage<data_size, align_size>::type; //内存对齐的缓冲区类型
其次,我们还要实现对缓冲区的构造、拷贝、析构和移动,因为Variant重新赋值的时候需要将缓冲区中原来的类型析构掉,拷贝构造和移动构造时则需要拷贝和移动。这里以析构为例,我们需要根据当前的type_index来遍历Variant的所有类型,找到对应的类型然后调用该类型的析构函数。
void Destroy(const type_index& index, void * buf)
{
std::initializer_list<int>{(Destroy0<Types>(index, buf), )...};
} template<typename T>
void Destroy0(const type_index& id, void* data)
{
if (id == type_index(typeid(T)))
reinterpret_cast<T*>(data)->~T();
}
这里,我们通过初始化列表和逗号表达式来展开可变模板参数,在展开的过程中查找对应的类型,如果找到了则析构。在Variant构造时还需要注意一个细节是,Variant不能接受没有预先定义的类型,所以在构造Variant时,需要限定类型必须在预定义的类型范围当中,这里通过type_traits的enable_if来限定模板参数的类型。
template <class T,
class = typename std::enable_if<Contains<typename std::remove_reference<T>::type, Types...>::value>::type> Variant(T&& value) : m_typeIndex(typeid(void)){
Destroy(m_typeIndex, &m_data);
typedef typename std::remove_reference<T>::type U;
new(&m_data) U(std::forward<T>(value));
m_typeIndex = type_index(typeid(U));
}
这里enbale_if的条件就是前面实现的元函数Contains的值,当没有在预定义的类型中找到对应的类型时,即Contains返回false时,编译期会报一个编译错误。
最后还需要实现内置的Vistit功能,Visit的实现需要先通过定义一系列的访问函数,然后再遍历这些函数,遍历过程中,判断函数的第一个参数类型的type_index是否与当前的type_index相同,如果相同则获取当前类型的值。
template<typename F>
void Visit(F&& f){
using T = typename Function_Traits<F>::template arg<>::type;
if (Is<T>())
f(Get<T>());
} template<typename F, typename... Rest>
void Visit(F&& f, Rest&&... rest){
using T = typename Function_Traits<F>::template arg<>::type;
if (Is<T>())
Visit(std::forward<F>(f));
else
Visit(std::forward<Rest>(rest)...);
}
Visit功能的实现利用了可变模板参数和function_traits,通过可变模板参数来遍历一系列的访问函数,遍历过程中,通过function_traits来获取第一个参数的类型,和Variant当前的type_index相同的则取值。为什么要获取访问函数第一个参数的类型呢?因为Variant的值是唯一的,只有一个值,所以获取的访问函数的第一个参数的类型就是Variant中存储的对象的实际类型。
7总结
C++11中的一些特性比如type_traits、可变模板参数和tuple让模版元编程变得更简单也更强大,模版元编程虽然功能强大,但也比较复杂,要用好模版元,需要我们转变思维方式,在掌握基本的理论的基础上,再认真揣摩模版元的一些常用技巧,这些技巧是有规律可循的,基本上都是通过重定义、递归和偏特化等手法来实现的,当我们对这些基本技巧很熟悉的时候再结合不断地实践,相信对模版元编程就能做到“游刃有余”了。
本文曾发表于《程序员》2015年3月刊。转载请注明出处。
后记:本文的内容主要来自于我在公司内部培训的一次课程,因为很多人对C++11模板元编程理解得不深入,所以我觉得有必要拿出来分享一下,让更多的人看到,就整理了一下发到程序员杂志了,我相信读者看完之后对模版元会有全面深入的了解。
C++11模版元编程的更多相关文章
- C++11模版元编程的应用
1.概述 关于C++11模板元的基本用法和常用技巧,我在程序员2015年2月B<C++11模版元编程>一文(后称前文)中已经做了详细地介绍,那么C++11模版元编程用来解决什么实际问题呢, ...
- C++11用于元编程的类别属性
[C++11用于元编程的类别属性] 许多算法能作用在不同的数据类别; C++ 模板支持泛型,这使得代码能更紧凑和有用.然而,算法经常会需要目前作用的数据类别的信息.这种信息可以通过类别属性 (type ...
- C++ 模板元编程 学习笔记
https://blog.csdn.net/K346K346/article/details/82748163 https://www.jianshu.com/p/b56d59f77d53 https ...
- 【48】认识template元编程
1.TMP(template metaprogramming),模版元编程有两个效力:第一,它让某些事情更容易:第二,可将工作从运行期转移到编译期.
- 用 C++ 模板元编程实现有限的静态 introspection
C++ 中的奇技淫巧大部分来源于模板技术,尤其是模版元编程技术(Template Meta-Programming, TMP).TMP 通过将一部分计算任务放在编译时完成,不仅提高了程序的性能,还能让 ...
- C++11新特性之六——元编程
C++11新特性之六——元编程
- C++模板元编程(C++ template metaprogramming)
实验平台:Win7,VS2013 Community,GCC 4.8.3(在线版) 所谓元编程就是编写直接生成或操纵程序的程序,C++ 模板给 C++ 语言提供了元编程的能力,模板使 C++ 编程变得 ...
- c++ 模板元编程的一点体会
趁着国庆长假快速翻了一遍传说中的.大名鼎鼎的 modern c++ design,钛合金狗眼顿时不保,已深深被其中各种模板奇技淫巧伤了身...论语言方面的深度,我看过的 c++ 书里大概只有 insi ...
- C++ 元编程 —— 让编译器帮你写程序
目录 1 C++ 中的元编程 1.1 什么是元编程 1.2 元编程在 C++ 中的位置 1.3 C++ 元编程的历史 2 元编程的语言支持 2.1 C++ 中的模板类型 2.2 C++ 中的模板参数 ...
随机推荐
- 003 将spark源码导入到IDEA中
1.解压源代码 2.进入IDEA的首界面 3.使用open将解压的工程加载 4.将文件的形式改成maven项目 5.使用
- Shell function
function test() { echo $1 echo $2 echo $3 } test 1 2 4 在shell里面使用函数是不用括号的.参数直接接在名字后面.
- 图解 Java 内存模型
图解 Java 内存模型 (图片来自于:http://www.cnblogs.com/zhangs1986/p/7903722.html)
- POJ 2417 Discrete Logging BSGS
http://poj.org/problem?id=2417 BSGS 大步小步法( baby step giant step ) sqrt( p )的复杂度求出 ( a^x ) % p = b % ...
- CocosCreator内置函数实现物体拖动
通过CocosCreator由内置的cc.Node.EventType.MOUSE_MOVE鼠标(触摸)事件实现,返回参数为鼠标的坐标值. 根据鼠标的x,y实现物体的移动,即将鼠标放置在该节点上,实现 ...
- GitHub 的公开演讲文化
2013年在某个地方为GitHub 240名员工中的三分之一或一半员工做演讲. 鼓励你的员工在大会上做演讲通常被认为是一件好事.另外对于GitHub,它还是一种好的广告:和我们花钱砸在banner广告 ...
- p4 环境变量的优先级
Perforce settings such as port, user, and workspace names using the following methods, listed in ord ...
- springboot2.X 集成redis+消息发布订阅
需求场景:分布式项目中,每个子项目有各自的 user 数据库, 在综合管理系统中存放这所有用户信息, 为了保持综合管理系统用户的完整性, 子系统添加用户后将用户信息以json格式保存至redis,然后 ...
- 在 Visual Studio 2010 中配置SharpPcap
最近需要在C#下写一个抓取ARP包的程序,网上找来找去,在C#下只能用SharpPcap来做了.SharpPcap是作者把winPcap用C#重新封装而来的,详细信息见如下的链接. SharpPcap ...
- centos7下安装gcc7
之前写过在linux下升级gcc 4.8至gcc 4.9的过程,现在gcc最新的版本是8,有些软件必须是gcc 7或者以上的版本才可以编译,比如clickhouse,gcc 7的安装过程和之前基本上一 ...