C++模板元编程实战-优快云博客

《C++11/14高级编程：Boost程序库探秘》笔记

模板元编程简称元编程，本质上是泛型编程的一个子集，所以从广义上说，所有使用template的泛型编程都可以称作元程序——因为泛型代码并不是真正可编译执行的代码。
模板元编程的运行是在编译期，它把编译器变成了元程序的解释器。

语法元素

模板元编程产生的元程序是在编译期执行的程序，操作的对象也不是普通的变量，因此不能使用运行时的C++关键字（如if、else、for)，可用的语法元素相当有限，最常用的几种：

enum、static，用来定义编译期的整数常量
typedef、using（C++11/14），最重要的元编程关键字，用来定义元数据
template，模板元编程的“起点”，主要用于定义元函数
“::”，域运算符，用于解析类型作用域获取计算结果（元数据）

元数据

元编程可操作的数据称为“元数据”(meta data)，也就是C++编译器在编译期可操作的数据，它是模板元编程的基础。元数据都是不可变的，不能就地修改，最常见的是整数和C++的类型(type)。

元函数

元函数是模板元编程中用于操作处理元数据的“构件”，可以在编译期被“调用”，功能形式类似运行时的函数，但形式上却是一个模板类。

函数参数列表圆括号变成了模板列表声明的尖括号
函数的形参变成了模板参数（即元数据），并且要使用关键字typedname修饰
因为不能使用运行时关键字，所以元函数不能像普通函数那样使用return返回结果，而需要在元函数内部用typedef/using定义一个名为type的类型或名为value的值作为返回
元函数最后以分号结束

template<int N,int M>
struct meta_func
{
    static const int value = N + M;
};

cout << meta_func<10, 10>::value << endl;
int i = 10, j = 10;
meta_func<i, j>::value; // error,i,j为运行时变量

元函数可以使用typedef/using关键字返回多个返回值，并且没有顺序关系，能够用”::”获取。

元函数转发

使用public继承，模板参数传递给父类完成元函数的“调用”，子类会自动获得父类的::type定义，同时也完成了元函数的返回。

struct select1st
{
    typedef T1 type;
};

template<typename T1,typename T2>
struct forward :select1st<T2,T1>    //默认public继承
{

};

等价于：

template<typename T1,typename T2>
struct forward
{
    typedef typename select1st<T2, T1>::type type;  //调用元函数计算
};

mpl工具库

mpl是专门为模板元编程创建的工具库，提供了大量高质量高效的元编程工具，包括：

基本的数据类型：整数、pair、void等运行时类型的对应物
基本的数据运算：以元函数形式提供的算术运算、逻辑运算等运算功能
程序流程控制：以元函数形式提供的分支流程处理功能
容器：模仿STL风格的存储元数据（类型）的编译期容器
视图：容器的适配器，可以简化容器的操作
迭代器：模仿STL风格应用于容器的编译期迭代器
算法：模仿STL风格应用于容器和迭代器的编译期算法
高阶元数据：类似于函数对象的元编程构件
bind/lambda表达式：编译期的lambda表达式，功能强大灵活
调试支持：提供了编译期的断言功能
辅助宏：各种配置宏和traits宏

mpl由头文件组成，所有组件位于名字空间boost::mpl，源代码在目录<boost/mpl>下，文件名和组件名一致，不存在统一的头文件，所以要手工添加包含的头文件。

整数类型

虽然整数本身就是元数据，在编译期可以计算，但直接操作整数对于元编程并不太方便，因为元编程更大的作用是类型计算，整数不是类型，为此，mpl库提供了数值包装器概念，把整数（int、long、bool等类型）包装为值元函数。
mpl库里的数值包装器元函数共有六个，分别包装了不同的整数类型（没有short）：

char_<N>            :包装char类型，值为N
int_<N>             :包装int类型，值为N
long_<N>            :包装long类型，值为N
size_t<N>           :包装size_t类型，值为N
intergral_c<T,N>    :包装类型为T的整数类型，值为N
bool_<N>            :包装bool类型，值为N

这些元函数都有基本相同的形式，类摘要如下：

struct integral_wrapper //整数包装器
{
    BOOST_STATIC_CONSTANT(T, value = N);    //包装整数值N
    typedef integral_c_tag  tag;            //类型标记
    typedef T               type;           //返回自身
    typedef T               value_type;     //整数类型
    operator T() const { return this->value; }  //转型操作

    //bool没有下列两个元数据
    typedef some_define     next;           //++N
    typedef some_define     prior;          //--N
};

用法也基本相同，用::type返回自身，用::value返回被包含的整数值，对于非bool类型，提供了 next和prior两个内部类型定义，可以获得类似operator++和operator–效果，同时重载了转型操作，使得它们的实例可以在运行时隐式转换为被包装的整数。

#include <type_traits>
#include <boost/mpl/int.hpp>
#include <boost/mpl/integral_c.hpp>
#include <boost/mpl/prior.hpp>
using namespace boost::mpl;

typedef int_<2> i2;
typedef integral_c<short, 2> s2;

int main()
{
    assert(i2::value == 2);
    assert(i2::value == s2::value);

    //is_same<T1,T2>::value比较T1和T2两个的类型是否一致
    assert((std::is_same<i2::type, i2>::value));
    assert((std::is_same<s2::value_type, short>::value));

    assert(i2::next::value == 3);           //内部成员获取递增值
    assert(prior<s2>::type::value == 1);    //使用元函数获取递减值

    i2 two1;    //声明两个包装器实例
    s2 two2;    //值均为常量2

    int i = two1 + two2;        //隐式类型转换为int参与运行时计算
    assert(i == int_<4>());     //与int_元函数比较，使用()创建临时对象
    return 0;
}

mpl库提供了同C++内建的整数运算一样的整数类型运算：

递增递减运算：位于头文件<boost/mpl/next_prior.hpp>，包括next和prior两个元函数，不支持bool_。
算术运算：位于头文件<boost/mpl/arithmetic.hpp>，包括加减乘除、取模、取负值，支持使用多个参数，元函数有plus,minus,negate等。
比较运算：位于头文件<boost/mpl/comparison.hpp>，包括小于，大于，等于和不等于六种，元函数有less，greater，equal_to等。
位运算：位于头文件<boost/mpl/bitwise.hpp>，包括与、或、异或、移位等，元函数有bitand_、bitor_等。
逻辑运算：位于头文件<boost/mpl/logical.hpp>，包括与、或、非三种逻辑运算，元函数有and_、or_和not_。
其他运算：包括最大最小值min/max、整数的大小sizeof_等。

流程控制

mpl提供了四个元函数用于分支结构，类似于运行时的if-else语句

if_和if_c
近似于 ?: 操作符

template<bool C,typename T1,typename T2>
struct if_c
{
    typedef T1 type;
};

template<typename T1,typename T2>
struct if_c<false, T1, T2>          //if_c对false模板偏特化
{
    typedef T2 type;
};

template<typename C,typename T1, typename T2>
struct if_
{
    typedef if_c<C::value, T1, T2> almost_type_t;
    typedef typename almost_type_t::type type;
};

if_c和if_ 的条件不同，前者是bool类型，后者是一个有::value返回的值元函数（不一定是bool_）。

typedef if_c<true, int, long>::type mdata1;
assert((is_same<mdata1, int>::value));

typedef if_<boost::mpl::false_, float, double>::type mdata2;
assert((is_same<mdata2, double>::value));

if_c 和if_ 不能有选择地忽略不需要计算的数据（缓式评估）,必须计算所有的元数据，增加了计算时间。

eval_if和eval_if_c
这两者的出现是为了解决上述if_c和if_ 的缺陷：缓式评估问题

template<bool C,typename F1,typename F2>
struct eval_if_c
    : if_c<C,F1,F2>::type   //元函数转发
{};

template<typename C,typename F1, typename F2>
struct eval_if
    : if_<C,F1,F2>::type
{};

使用时需要注意，后两个模板参数必须是元函数。

typedef eval_if_c<true, identity<int>, identity<long>>::type mdata1;
assert((is_same<mdata1, int>::value));

typedef eval_if<is_integral<mdata1>, identity<float>, identity<double>>::type mdata2;
assert((is_same<mdata2, float>::value));

mpl容器

mpl容器与标准库的容器相似，但容纳的元素都是元数据（也就是类型），没有对元素的可拷贝可赋值要求。mpl容器没有成员函数，自身不能操纵容器内元素，只能通过外部元函数处理。
mpl序列容器包括以下内容：

list：不同于std::list，它是一个单向链表，只能在序列的前端操作元素可以容纳无限个元素
vector：跟std::vector一样有随机访问的功能，但它又有std::list的特性，可以在两端操作元素，容量有限，缺省最多能容纳20个元数据
deque：类似std::deque，可以在两端操作元素。

mpl关联容器缺省最多能容纳20个元素，包含以下两种：

set：类似std::multiset，是一个允许重复的元数据集合
map：类似std::multimap，是一个允许重复的元数据映射关系集合

除了上述五个基本容器，mpl库还针对整数类型提供了一些特别的整数容器：

range_c<T,N,M> ：不可修改的包含[N,M]区间内整数的vector容器
list_c<T,…> ：包含类型为T的若干整数的list容器
vector_c<T,…> ：包含类型为T的若干整数的vector容器
set_c<T,…> ：包含类型为T的若干整数的set容器
string ：专门存储char字符的容器，类似std::string，可以在编译期处理的字符串

判断一个类型是否是mpl容器可以用元函数is_sequence。

mpl容器的相关元函数
1) 容器容量操作。

empty<C>
size<C>

2)元素访问操作。

front<C>
back<C>
at<C,k> ：对于序列容器，返回第k个位置上的元素，对于关联容器，返回键为k的元素
at_c<C,n> ：仅用于序列容器，返回第n个位置上的元素(n是long型整数)

3)迭代器操作

begin<C>
end<C>

4)元素变动操作

push_front<C,t>
push_back<C,t>
pop_front<C>
pop_back<C>
clear<C>
erase<C,pos>/erase<C,f,l>
insert<C,pos,t>/insert<C,t>

容器是元数据，元数据是不可变的，所以变动操作都必须返回一个新的容器，原容器不会变化

5)关联容器特有操作

has_key<C,k>
erase_key<C,k>

mpl迭代器

mpl所有的迭代器都是只读，可分为三类：

前向迭代器：可以使用元函数next前进
双向迭代器：在前向迭代器的基础上增加使用元函数prior后退，即可逆向遍历
随机访问迭代器：在双向迭代器的基础上增加迭代器的距离运算

提供的迭代器元函数包括以下几个：

deref<I> : 解引用迭代器，返回元数据
next<I> ：前进迭代器
prior<I> ：后退迭代器
advance<I,n> ：迭代器移动n个位置，对于双向迭代器n可以是负值
distance<I1,I2> ：返回两个迭代器之间的距离
iterator_category<I> ：获得迭代器的分类标志

mpl算法

1)插入器

back_inserter<C> ：在容器后端插入元素，要求支持push_back
front_inserter<C> ：在容器前端插入元素，要求支持push_front
inserter<S,Op> ：通用的插入器，以初始状态S开始执行Op操作完成插入动作。

typedef mpl::vector<char,int,long> vec; //容纳三个元素
typedef copy<vec,mpl:back_inserter<vec>>::type vec2; //插入自己，相当于双倍
assert((size<vec2>::value == 6));

typedef mpl::string<> str1;
typedef copy<mpl::string<'time'>, //临时元数据
    mpl::front_inserter<str1>>::type str2;
cout << c_str<str2>::value;     //输出字符串emit

2)查询算法

find<C,t> ：查找元素t,返回迭代器
contains<C,t> ：值元函数，检查是否存在元素t
count<C,t> ：值元函数，返回容器中元素t的个数
equal<C1,C2> ：值元函数，比较两个容器是否等价，即元数据相同，容器可能是不同类型

3)变换算法
变换算法处理容器中的全部或部分元素，然后返回一个新的容器，带前缀”reverse_”的形式可以返回操作后的逆序容器。

copy<From,To> ：拷贝一个容器里所有的元素
replace<From,Old,New,To> ：把容器中的Old元素全部替换为New元素
remove<From,t,To> ：移除容器中所有值为t的元素
reverse<From,To> ：逆序拷贝容器里的所有元素

最后一个参数To可以省略不用，直接用::type返回变换后的新容器，如果使用，那么通常需要搭配插入器工作。

4)运行时算法
mpl中for_each算法可以遍历类型容器，工作在运行时，调用一个函数对象操作类型容器里类型对应的实例对象。
for_each算法是一个模板函数，有两个模板参数，第一个参数是mpl容器，必须显式指定，第二个是函数对象，它应具有模板成员函数operator()，能够处理mpl容器中的所有类型，否则编译错误。

struct mpl_func1
{
    template<typename T>
    void operator()(T t)
    {
        cout << typeid(t).name() << endl;
    }
};

struct mpl_func2
{
    template<typename T>
    void operator()(T t)
    {
        if(is_same<typename tag<T>::type,integral_c_tag>::value)
        {
            cout << t << ',';
        }
    }
};

int main()
{
    typedef range_c<int, 0, 5> rc;
    typedef mpl::vector<> vec;

    typedef mpl::copy<rc,
        mpl::back_inserter<vec>>::type vec2;

    typedef push_front<vec2, float>::type vec3;

    mpl::for_each<vec3>(mpl_func1());
    mpl::for_each<vec3>(mpl_func2());
    return 0;
}

运行结果如下：

float
struct boost::mpl::integral_c<int,0>
struct boost::mpl::integral_c<int,1>
struct boost::mpl::integral_c<int,2>
struct boost::mpl::integral_c<int,3>
struct boost::mpl::integral_c<int,4>
0,1,2,3,4,

元编程断言

mpl库在头文件<boost/mpl/assert.hpp>中特意定义了几个元编程断言，能够在元程序发生错误时提供有用的信息。

基本断言
宏BOOST_MPL_ASSERT是最常用的一个静态断言，它使用一个返回bool_值元函数pred作为参数，断定pred::value为真，调用形式：
BOOST_MPL_ASSERT((pred)); //必须两对圆括号

typedef mpl::vector<int,char> vec;
BOOST_MPL_ASSERT((is_same<int,front<vec>::type>));  //注意不需要::value
BOOST_MPL_ASSERT((equal_to<size<vec>::type,int_<3>>));

第二个断言会在编译时报出形如”***pred::***”的错误，同时出现行号。

否定断言
BOOST_MPL_ASSERT_NOT
关系断言
BOOST_MPL_ASSERT_RELATION(x,rel,y)
x,y是两个编译期整数（非包装器）,rel是一个合法的C++关系操作符，如==、<。
这个不需要两对圆括号
定制消息断言
BOOST_MPL_ASSERT_MSG(c,msg,types_)
c:条件表达式，非元函数
msg：自定义的消息，但不是一个C字符串，而是一个符合C++语法的标志符
types_：类型列表

实例研究

实现一个动态加载动态链接库函数功能的实例研究
先编译一个简单的动态库：

//libtest.h
#ifdef __cplusplus
extern "C"
{
#endif
    int so_func1(int x);
    int so_func2(int x,int y);
#ifdef __cplusplus
}
#endif

//libtest.cpp
#include "libtest.h"
int so_func1(int x)
{
    return x*x;
}
int so_func2(int x,int y)
{
    return x + y;
}

//g++-4.8 libtest.cpp -fPIC -shared -o libtest.so

1.泛型编程版本

简单地封装了一个so操作类

//gp_version.cpp
#include <iostream>
#include <stdexcept>    //runtime_error
#include <dlfcn.h>      //UNIX动态链接头文件
#include "libtest.h"

class DlManager         //定义一个加载so函数的包装类
{
public:
    DlManager(const char* name) 
    {
        m_h = dlopen(name,RTLD_NOW);    //使用文件名加载so
    }
    ~DlManager()
    {
        dlclose(m_h);
    }

    template<typename FuncType>
    FuncType load(const char* func_name)
    {
        FuncType pf = reinterpret_cast<FuncType>(dlsym(m_h,func_name)); //强制类型转换

        if(!pf)
        {
            throw std::runtime_error(dlerror());
        }

        return pf;
    }
private:
    typedef void* handle_t;     //句柄类型定义
    handle_t m_h;               //so文件的句柄
};

typedef int (*Func1)(int);
typedef int (*Func2)(int,int);

int main()
{
    DlManager dm("./libtest.so");

    Func1 f1 = dm.load<Func1>("so_func1");
    Func2 f2 = dm.load<Func2>("so_func2");

    std::cout << f1(10) << std::endl;
    std::cout << f2(10,20) << std::endl;

    return 0;
}

//g++-4.8 gp_version.cpp -ldl -o gp_version

2.元编程第1版

加载动态库这个过程，可以分解成两部分：一部分是编译期的数据，包括文件名、函数名以及函数指针类型，另一部分是运行时代码，包括加载so文件和获取so函数，泛型版本没有把这两者很好地解耦，而是将两者在运行时混合在一起了。
为了明确区分编译和运行时的数据，使用mpl把程序分为前端和后端两个部分，前端使用mpl定义编译期数据，后端使用前端数据实现运行时功能。

前端
前端数据有so文件名、接口函数名和函数指针类型，前两者可以使用mpl::string表述，后者本身就是元数据，为了实现函数名与函数指针类型的对应关系，可以使用mpl::map，最后用struct把这些数据封装成一个前端类。

后端
后端与泛型版本差不多，只不过操作的数据变成了前端的元数据，把后端实现为一个模板类，这样就可以使用不同的前端类支持不同的so加载功能。

//mp_version1.cpp
#include <iostream>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/string.hpp>
#include <boost/mpl/map.hpp>
#include <boost/mpl/at.hpp>
#include <dlfcn.h>      //UNIX动态链接头文件
#include "libtest.h"
namespace mpl = boost::mpl;

struct dl_front
{
    typedef mpl::string<'./','lib','test','.so'> so_name;

    typedef int (*Func1)(int);
    typedef int (*Func2)(int,int);

    typedef mpl::string<'so_','func','1'> func1_name;
    typedef mpl::string<'so_','func','2'> func2_name;

    typedef mpl::map<
        mpl::pair<func1_name,Func1>,
        mpl::pair<func2_name,Func2>
        > map_fun;
};

template<typename Front>
class dl_back
{
private:
    void* m_h = NULL;
public:
    dl_back()
    {
        m_h = dlopen(mpl::c_str<typename Front::so_name>::value,RTLD_NOW);
    }
    ~dl_back()
    {
        dlclose(m_h);
    }

    template<typename FuncName>
    typename mpl::at<typename Front::map_fun,FuncName>::type    //返回类型
    func_ptr()
    {
        typedef typename mpl::at<typename Front::map_fun,FuncName>::type result_type;
        result_type pf = reinterpret_cast<result_type>(dlsym(m_h,mpl::c_str<FuncName>::value));

        return pf;
    }
};

int main()
{
    dl_back<dl_front> dl;
    std::cout << dl.func_ptr<dl_front::func1_name>()(10) << std::endl;
    std::cout << dl.func_ptr<dl_front::func2_name>()(10,20) << std::endl;

    return 0;
}

//g++-4.8 mp_version1.cpp -ldl -o mp_version1

在调用成员函数func_ptr()时，除了显式写出前端定义的函数名外，还必须调用两次operator()，因为第一次调用只是获取了函数指针，第二次调用材质真正的so接口函数调用。

3.元编程第2版

第一版的元编程还可以增强成员函数func()，直接传递参数减少一次operator()调用。要减少一个operator()调用，就要求函数func()返回的是so函数指针的返回类型而不是函数指针类型，同时传递相应数量的参数，前者可以使用result_of结合mpl来自动推导函数的返回值类型，后者可以用可变模板参数列表解决。
改进后func()代码：

template<typename FuncName,typename ... Args>   //可变参数模板
    typename boost::result_of<                      //使用result_of推导函数的返回值
        typename mpl::at<typename Front::map_fun,FuncName>::type(Args...)
        >::type
    func(Args const& ...args)
    {
        typedef typename mpl::at<typename Front::map_fun,FuncName>::type func_type; //得到函数指针类型
        func_type pf = reinterpret_cast<func_type>(dlsym(m_h,mpl::c_str<FuncName>::value)); //获取函数指针

        return pf(args...); //直接调用函数指针
    }

也可以直接使用第一版写好的func_ptr()函数直接返回函数指针来调用：

template<typename FuncName,typename ... Args>   //可变参数模板
    typename boost::function_traits<            //改用function_traits推导类型
        typename boost::remove_pointer<         //需要先移除类型里的指针
            typename mpl::at<typename Front::map_fun,FuncName>::type
            >::type             
        >::result_type                  //获取函数的返回值
    func_V(Args const& ... args)
    {
        return func_ptr<FuncName>()(args...);
    }

完整代码：

//mp_version2.cpp
#include <iostream>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/string.hpp>
#include <boost/mpl/map.hpp>
#include <boost/mpl/at.hpp>
#include <boost/utility/result_of.hpp>
#include <boost/type_traits.hpp>
#include <dlfcn.h>      //UNIX动态链接头文件
#include "libtest.h"
namespace mpl = boost::mpl;

struct dl_front
{
    typedef mpl::string<'./','lib','test','.so'> so_name;

    typedef int (*Func1)(int);
    typedef int (*Func2)(int,int);

    typedef mpl::string<'so_','func','1'> func1_name;
    typedef mpl::string<'so_','func','2'> func2_name;

    typedef mpl::map<
        mpl::pair<func1_name,Func1>,
        mpl::pair<func2_name,Func2>
        > map_fun;
};

template<typename Front>
class dl_back
{
private:
    void* m_h = NULL;
public:
    dl_back()
    {
        m_h = dlopen(mpl::c_str<typename Front::so_name>::value,RTLD_NOW);
    }
    ~dl_back()
    {
        dlclose(m_h);
    }

    template<typename FuncName>
    typename mpl::at<typename Front::map_fun,FuncName>::type    //返回类型
    func_ptr()
    {
        typedef typename mpl::at<typename Front::map_fun,FuncName>::type result_type;
        result_type pf = reinterpret_cast<result_type>(dlsym(m_h,mpl::c_str<FuncName>::value));

        return pf;
    }

    template<typename FuncName,typename ... Args>   //可变参数模板
    typename boost::result_of<typename mpl::at<typename Front::map_fun,FuncName>::type(Args...)>::type  //使用result_of推导函数的返回值
    func(Args const& ... args)
    {
        typedef typename mpl::at<typename Front::map_fun,FuncName>::type func_type; //得到函数指针类型
        func_type pf = reinterpret_cast<func_type>(dlsym(m_h,mpl::c_str<FuncName>::value)); //获取函数指针

        return pf(args...); //直接调用函数指针
    }

    template<typename FuncName,typename ... Args>   //可变参数模板
    typename boost::function_traits<typename boost::remove_pointer<typename mpl::at<typename Front::map_fun,FuncName>::type>::type>::result_type                //获取函数的返回值 //改用function_traits推导类型
    func_V(Args const& ... args)
    {
        return func_ptr<FuncName>()(args...);
    }

};

int main()
{
    dl_back<dl_front> dl;
    std::cout << "----------------mp version 2-----------" << std::endl;
    std::cout << dl.func<dl_front::func1_name>(10) << std::endl;
    std::cout << dl.func<dl_front::func2_name>(10,20) << std::endl;

    std::cout << "----------------mp version 2-----------" << std::endl;
    std::cout << dl.func_V<dl_front::func1_name>(10) << std::endl;
    std::cout << dl.func_V<dl_front::func2_name>(10,20) << std::endl;

    return 0;
}

//g++-4.8 mp_version2.cpp -ldl -o mp_version2