C++11 模板元编程 - 一切都是函数

---

前面我们对整形和bool提供了模板包装，可以将一个具体的值变为一个类型。例如IntType<5>和IntType<6>就是两个不同的类型，而BoolType和TrueType则是相同的类型。

从另一个角度来看IntType，它其实也是个元函数：接收一个int型常量，返回一个类型。BoolType也是一样的。为了简化对它们的使用，我们使用宏将其封装一下：

#define __int(value)    typename IntType::Result

#define __bool(...)    typename BoolType<__VA_ARGS__>::Result
#define __true()       typename TrueType::Result
#define __false()      typename FalseType::Result

后续我们可以如此使用：__int(5)，__int(6)，__bool(true)，__true()，__false()，这样的用法看起来更像是函数。事实上，你即可以认为它们是类型，也可以认为它们都是一些创建型函数，其中__true()和__false()比较特殊，没有参数而已。

由于IsEqual也比较常用，所以我们将其也用宏封装一下：

#define __is_eq(...)   typename IsEqual<__VA_ARGS__>::Result

如此上节例子中的打印代码，就可以简化如下：

// TestPrint.cpp

__print(__is_eq(__int(5), __int(6)));
__print(__is_eq(__true(), __bool(true)));

现在可以看到，构成整个计算的似乎都是函数。其实所有的类型都可以看作是函数，你可以将其想成是一个个创建函数，无非大多数都非常简单不需要参数而已。反过来所有的函数也都可以被看成是类型，当得到入参后，函数就变成其返回值对应的类型。

如此看待程序的方式非常的有意义，《计算机程序的构造与解释》一书里面有一章专门提到这个思想，比这里更加的深邃和彻底。这种思想产生的设计技巧非常的有用。例如对于运行期C++中的一个函数，我们认为它是一个对数据进行操作的过程，然而当我们把这个函数的指针进行保存和传递的时候，它又变成了数据。如此我们就可以把一段计算方式进行存储和转移，在想要的时机再进行运算求值。在OO中，我们熟知的Command设计模式就是这个思路。

有的时候，我们可能需要获得某个IntType或者BoolType里面的实际数值，所以在IntType和BoolType的定义中，仍然存在一个enum值Value。虽然我们可以像这样__int(5)::Value获得其内部数值，但是这样的用法和我们的元编程规范是不一致的！我们可以实现一个Value元函数，专门用来对类型求值。

// “tlp/base/algo/Value.h”

template
struct Value
{
    enum { Result = T::Value };
};

#define __value(...)    Value<__VA_ARGS__>::Result

Value元函数是整个TLP库中仅有的一个用Result表示非类型的元函数，它一般使用在一个元编程表达式的最后，用于将整个表达式进行求值，然后将值传递给运行期C++，所以并不会对元函数的组合造成问题。

由于我们在IntType和BoolType中定义了内部enum成员Value，所以可以直接对其调用Value元函数：

std::cout << __value(__int(5)) + __value(__int(6)) << std::endl;
std::cout << __value(__true()) && __value(__bool(false)) << std::endl;

上面代码中我们使用Value元函数在编译期对IntType和BoolType进行求值，然后在运行期进行数值的相加计算和bool的逻辑与计算，将结果输出。

能否直接就在编译期就对IntType进行数值运算，对BoolType进行逻辑运算呢？可以，定义针对IntType和BoolType专门的运算元函数即可。

如下我们定义IntType的加法运算元函数，它接收两个IntType类型做入参，返回一个新的IntType，其Value是两个入参IntType的Value之和。

// “tlp/int/algo/Add.h”

template struct Add;

template
struct Add, IntType>
{
    using Result = IntType;
};

#define __add(...)    typename Add<__VA_ARGS__>::Result

我们可以在编译期打印出计算结果来：__print(__add(__int(5), __int(6)))。

在TLP库中一共针对IntType定义了如下基本运算元函数：

• __inc() : 递增运算。例如 __inc(__int(5))的结果是__int(6);
• __dec() : 递减运算。例如 __dec(__int(5))的结果是__int(4);
• __add() : 加法运算。例如 __add(__int(5), __int(2))的结果是__int(7);
• __sub() : 减法运算。例如 __sub(__int(5), __int(2))的结果是__int(3);
• __mul() : 乘法运算。例如 __mul(__int(5), __int(2))的结果是__int(10);
• __div() : 除法运算。例如 __div(__int(5), __int(2))的结果是__int(2);
• __mod() : 取模运算。例如 __mod(__int(5), __int(2))的结果是__int(1);

同样，TLP对于BoolType定义了如下基本的逻辑运算元函数：

• __not()：取非操作。例如：__not(__bool(true))的结果是__false()；
• __and()：逻辑与操作。例如：__and(__true(), __false())的结果是__false()；
• __or()：逻辑或操作。例如：__or(__true(), __false())的结果是__true()；

有了上述元函数，我们就可以在编译期将int和bool当做类型进行计算了。

如果需要对类型计算结果取值，可以如下在运算表达式的最后调用Value元函数。

std::cout << __value(__add(__int(5), __int(6))) << std::endl;

前面介绍的了Value元函数的定义，它假设入参类型里面定义着名为Value的数值成员，我们自定义的IntType和BoolType都满足这个约束。而通过对Value的模板特化，可以无侵入性地对不满足这一约束的类型进行扩展。这其实就是我们熟知的C++ traits技术。

例如对TLP库中的空类：EmptyType，它内部并无Value成员，我们通过定义一个Value元函数的特化版本实现对其无侵入性地扩展。代码如下：

// “tlp/base/EmptyType.h”

struct EmptyType
{
};

#define __empty() EmptyType

template<>
struct Value
{
    enum { Result = 0 };
}

这样就可以对EmptyType也调用Value元函数了：__value(__empty())。

仔细观察上面这个表达式，一切都是函数，COOL！

---

模式匹配

返回 C++11模板元编程 - 目录