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 = 1, j = 2;
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, 1>;

或者

template<class T>
struct one_type : std::integral_constant<int, 1>{};

　　获取常量则通过one_type::value来获取，这种定义编译期常量的方式相比C++98/03要简单，在C++98/03中定义编译期常量一般是这样定义的：

template<class T>
struct one_type
{
    enum{value = 1};
};

template<class T>
struct one_type
{
    static const int value = 1;
};

　　可以看到，通过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 0;
}

　　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[2]>::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); //返回整数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 0;
}

template <class T>
typename std::enable_if<!std::is_arithmetic<T>::value, int>::type foo1(T &t)
{
    cout << typeid(T).name() << endl;
    return 1;
}

　　对于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+1 };
};

template < typename T, typename... Rest >
struct IndexOf<T, T, Rest...>
{
    enum{ value = 0 };
};

template < typename T >
struct IndexOf<T>
{
    enum{value = -1};
};

　　用法：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 - 1, Types...>::type;
};

template<typename T, typename... Types>
struct At<0, T, Types...>
{
    using type = T;
};
    用法：
using T = At<1, 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>(), 0)...};
}
用法：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 - 1, N - 1, Indexes...>{};

template<int... indexes>
struct MakeIndexes<0, 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<0>::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 = 1;
v = 'a';
v = 12.32;

　　这个variant可以接受已经定义的那些类型，看起来有点类似于c#和java中的object类型，实际上variant是擦除了类型，要获取它的实际类型的时候就稍显麻烦，需要通过boost.visitor来访问：

 View Code

　　通过C++11模版元实现的Variant将改进值的获取，将获取实际值的方式改为内置的，即通过下面的方式来访问：

typedef Variant<int, double, string, int> cv;
cv v = 10;
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。

 View Code

　　实现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), 0)...};
    }

    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<0>::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<0>::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++的世界变得更美好！

C++ 模板元编程

英文：C++ template metaprogramming
meta: “元”， 元数据（meta data)
metaprogramming可以理解为对程序语言自身的某种特性，对程序语句进行编程，
更简洁的说，对编程的编程--元编程。元编程有两种手段，一种是使用宏，另一种是使用模板。
今天聊的是模板元编程。

C++的模板元编程（TMP）主要是利用模板的特化和偏特化机制，在编译时获取类型信息，
并依照类型信息进行代码分发(dispatch)，简化代码编写，提高代码的可维护性以及省略
不必要的运行时代码路径选择。
这里提到了“编译时获取类型信息”，很多人可能觉得很奇怪：一般情况下，我们更感兴趣
的是“运行时获取类型信息”，而在编译时，编译器是肯定知道类型信息的，根本不需要获
取！没错，类型信息编译器是知道的，但我们不知道，更准确是我们的代码在编译时不知
道类型信息，TMP就是获取类型信息的手段。
上code之前，先解释：  
__CLRCALL_OR_CDECL   函数的调用约定
函数调用约定，是指当一个函数被调用时，函数的参数会被传递给被调用的函数和返回值
会被返回给调用函数。函数的调用约定就是描述参数是怎么传递和由谁平衡堆栈的，当然
还有返回值。（摘自百度百科）
几种类型
__stdcall，__cdecl，__fastcall，__thiscall，__nakedcall，__pascal，__vectorcall
约束事件
参数传递顺序
1.从右到左依次入栈：__stdcall，__cdecl，__thiscall，__fastcall
2.从左到右依次入栈：__pascal
调用堆栈清理
1.调用者清除栈。
2.被调用函数返回后清除栈。
举例：
template<class Init,class Diff>
inline void __CLRCALL_OR_CDECL advance(Init& Where,Diff Off){
    //这里根据第一个参数Where的具体型别，调用不同的模板Advance
    Advance(Where,Off,Iter_cat(Where));
}

template <class Iter>
inline typename iterator_traits<Iter>::iterator_category
__CLRCALL_OR_CDECL Iter_cat(const Iter&){
    //这里返回参数的具体型别，这在程序编译的时候编译器就可确定
    typename iterator_traits<Iter>::iterator_category  Cat;
    return Cat;
}

//根据Where型别不同，调用不同的模板特化版本
template<class Init,class Diff>
inline void __CLRCALL_OR_CDECL Advance(Init& Where,Diff Off,
                                        input_iterator_tag){
    #if _HAS_ITERATOR_DEBUGGING
    #endif
    for(;0<Off;--Off){
        ++Where;
    }
}
template<class Init,class Diff>
inline void __CLRCALL_OR_CDECL Advance(Init& Where,Diff Off,
                                bidirectional_iterator_tag){
    for(;0<Off;--Off){
        ++Where;
    }
    for(;Off<0;++Off){
        --Where;
    }
}
#pragma warning(pop)
template<class Init,class Diff>
inline void __CLRCALL_OR_CDECL Advance(Init& Where,Diff Off,
                            random_access_iterator_tag){
    Where += Off;
    }
}
观察advance内Advance最后一个参数Iter_cat(Where)，Iter_cat是一个辅助函数，它
根据迭代器的iterator_category返回这个iterator_category的实例，而Advance有多
个版本的重载，分别对应input、forward、bidirectional、randomaccess这些
iterator_category，因为有这些重载函数，advance就能通过迭代器自身
iterator_category类型调用到相对应的_Advance实现，更有趣的是_Advance的重载参数
根本就没有形参，它仅仅是为了捕捉类型信息。好，我们把这些连起来：advance调用
Advance，Iter_cat析出迭代器的类型信息，而Advance的最后一个参数捕捉类型信息，
完成编译时代码分发！！！
----好玩不？根据特化和偏特化可以这样玩，屌的很！

---

另外再对__CLRCALL_OR_CDECL 也就是函数调用约定进行深入了解下

为什么需要函数调用约定？

试想这样一个问题，当调用一个由别人编写的函数时，需要注意什么问题。

小明同学编写了一个函数  foo(int a,int b,int c);

当你调用foo(1,2,3)，参数如何传递，参数传递的顺序是什么，（当然还会涉及一些其他的问题）

你有3块不同的颜色的砖头（红，绿、蓝）

你可以通过双手（参数如何传递），分别 红 ，绿、 蓝  传递给另一面
你可以通过双手（参数如何传递），分别 蓝 ，绿 ， 红 传递给另一面
你可以通过汽车（参数如何传递），分别 红 ，绿、 蓝  传递给另一面
不管通过什么样的方式，传递顺序如何。另一面都接收到了参数，但是我们两者一致要约定好规则（传递顺序等其他规范），这样接收方就不会错误的领会到我的意思

不管怎样说，阅读到这里，你应该知道了，函数调用是有约定的，不能瞎搞（虽然这个问题在你编写代码时，没有直接让你处理，但是毕竟该问题是存在的）
约定由编译器实现（遵守不遵守编译器说了算），根据情况（X86,X64）有所不同，所以下面只是参照物
实际情况有哪些？

1. 参数传递的顺序（从右到左，从左到用）
2. 参数的存储容器的选择。（寄存器、栈区）
3. 如果使用栈区，谁来释放

记住这几条，然后不同的调用约定，就套用这些实际情况

-------------------------------------------------------------------------------------------------------------------------------------------------

                                  以上内容为本人学习摘录，来源多为网上搜索所得，如您认为侵犯您的版权，请留言告知，不胜感激。