C++11 模板元编程(4)-类型统一、函数统一

转载：https://www.jianshu.com/p/b56d59f77d53

基本类型转换成模板类型，通过函数去匹配实现

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

1.类型统一

// 对比两个变量的类型是否相等， 其实是对比typename与typename是否相等
template<typename T, typename U>
struct IsEqual
{
    enum {Result = false};
};

template<typename T>
struct IsEqual<T, T>    // 全特化，会先匹配这个类型，所以返回true
{
    enum {Result = true};
};

// 判断两个整数是否相等    // N, N是不是相等
template<int N, int M>    // 本文的思路是把int转换成typename,也就是上面的写法
struct IsNumEqual
{
    enum {Result = false};
};

template<int N>
struct IsNumEqual<N, N>
{
    enum {Result = true};
};

// 上面的逻辑是一样的，但名字必须不一样; 
// 所有的元函数的入参的型别和返回值型别都能一致化
// 数值也变成一个类型。
template<int V>
struct IntType
{
    enum { Value = V };
    using Result = IntType<V>;
};

// IntType<3>和IntType<4>就是不同的类型
// IntType<3>::Value获得它的数值

// 封装bool值
template<bool V> struct BoolType;

template<>
struct BoolType<true>
{
    enum { Value = true };
    using Result = BoolType<true>;
};

template<>
struct BoolType<false>
{
    enum { Value = false };
    using Result = BoolType<false>;
};

using TrueType = BoolType<true>;    // 相当于给BoolType<true>起别名
using FalseType = BoolType<false>;

// IsEqual只需要如下一份实现就够了
template<typename T, typename U>
struct IsEqual
{
    using Result = FalseType;    // 一切都是类型，没有具体的类型
};

template<typename T>
struct IsEqual<T, T>
{
    using Result = TrueType;
};

// error: 一切都是类型，5代表5类型，6代表6类型，这样就可以用第一种类型比较
__print(IsEqual<IntType<5>, IntType<6>>::Result);    // 成员变量
__print(IsEqual<TrueType, BoolType<true>>::Result);    // true

2.函数统一

 宏将其封装一下IntType，成为元函数：接收一个int型常量，返回一个类型

// 它们是类型，也可以认为它们都是一些创建型函数
// __int(5)，__int(6)，__bool(true)，__true()，__false()
#define __int(value) typename IntType<value>::Result
#define __bool(...)    typename BoolType<__VA_ARGS__>::Result
#define __true()       typename TrueType::Result
#define __false()      typename FalseType::Result
#define __is_eq(...)   typename IsEqual<__VA_ARGS__>::Result
__print(__is_eq(__int(5), __int(6)));
__print(__is_eq(__true(), __bool(true)));

// IntType或者BoolType里面的实际数值
template<typename T>
struct Value
{
    enum { Result = T::Value };
};

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

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

// 基本运算元函数
// add
template<typename T1, typename T2> struct Add;    // 主模板

template<int V1, int V2>    // 特化
struct Add<IntType<V1>, IntType<V2>>
{
    using Result = IntType<V1 + V2>;
};

#define __add(...)    typename Add<__VA_ARGS__>::Result
// __print(__add(__int(5), __int(6)));    // __int(11)
// std::cout << __value(__add(__int(5), __int(6))) << std::endl;
// __inc() : 递增运算。例如 __inc(__int(5))的结果是__int(6);

3.template<typename T> struct Value; 特化

比如TLP库中的空类：EmptyType，它内部并无Value成员，不能用struct Value; 通过定义一个Value元函数的特化版本实现对其无侵入性地扩展

struct EmptyType
{
};

#define __empty() EmptyType

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

__value(__empty())