从 C++98 到 C++17，元编程是如何演进的？ | 技术头条

作者 | 祁宇
责编 | 郭芮
出品 | CSDN（ID：CSDNnews）

不断出现的C++新的标准，正在改变元编程的编程思想，新的idea和方法不断涌现，让元编程变得越来越简单，让C++变得简单也是C++未来的一个趋势。

很多人对元编程有一些误解，认为代码晦涩难懂，编译错误提示很糟糕，还会让编译时间变长，对元编程有一种厌恶感。不可否认，元编程确实有这样或那样的缺点，但是它同时也有非常鲜明的优点：

• zero-overhead的编译期计算；

• 简洁而优雅地解决问题；

• 终极抽象。

在我看来元编程最大的魅力是它常常能化腐朽为神奇，帮我们写出dream code！

C++98模版元编程思想

C++98中的模版元编程通常和这些特性和方法有关：

• 元函数；

• SFINAE；

• 模版递归；

• 递归继承；

• Tag Dispatch；

• 模版特化/偏特化。

元函数

元函数就是编译期函数调用的类或模版类。比如下面这个例子：

template<class T> 
struct add_pointer { typedef T* type; };

typedef typename add_pointer<int>::type int_pointer;

addpointer就是一个元函数（模版类），元函数的调用是通过访问其sub-type实现的，比如addpointer::type就是调用add_pointer元函数了。

这里面类型T作为元函数的value，类型是元编程中的一等公民。模版元编程概念上是函数式编程，对应于一个普通函数，值作为参数传给函数，在模版元里，类型作为元函数的参数被传来传去。

SFINAE

替换失败不是错误。

template<bool B, class T = void>
struct enable_if {};

template<class T>
struct enable_if<true, T> { typedef T type; };

template <class T>
typename enable_if<sizeof(T)==4, void>::type
foo(T  t) {}

foo(1);  //ok
foo('a'); //compile error

在上面的例子中，调用foo('a')模版函数的时候，有一个模版实例化的过程，这个过程中会替换模版参数，如果模版参数替换失败，比如不符合编译期的某个条件，那么这个模版实例化会失败，但是这时候编译器不认为这是一个错误，还会继续寻找其他的替换方案，直到所有的都失败时才会产生编译错误，这就是SFINAE。SFINAE实际上是一种编译期的选择，不断去选择直到选择到一个合适的版本位置，其实它也可以认为是基于模板实例化的tag dispatch。

模版递归，模版特化

template <int n> struct fact98 {
  static const int value = n * fact98<n - 1>::value;
};
template <> struct fact98<0> {
  static const int value = 1;
};
std::cout << fact98<5>::value << std::endl;

这是模版元编程的hello world例子，通过模版特化和模版递归实现编译期计算。

在C++98中模版元编程的集大成者的库是boost.mpl和boost.fusion，boost.mpl主要提供了编译期类型容器和算法，boost.fusion通过异构的编译期容器融合编译期和运行期计算。

struct print{
template <typename T>
  void operator()(T const& x) const{
         std::cout << typeid(x).name() << std::endl;
    }
};

template <typename Sequence>
void print_names(Sequence const& seq){
    for_each(filter_if<boost::is_class<_> >(seq), print());
}
boost::fusion::vector<int, char, std::string> stuff(2018, 'i', "purecpp");
print_names(stuff);

上面这个例子遍历boost::fusion::vector异构容器，打印其中的string类型。

关于C++98模版元的书可以看《modern c++ design》和《c++ templates》。

Modern C++ metaprogramming编程思想

C++11中的元编程思想

Modern C++新标准对于元编程有着深刻的影响，一些新的编程思想和方法涌现，但总体趋势是元编程变得更简单了。比如C++98中的add_pointer元函数，我们需要写一个模版类：

template<class T> 
struct add_pointer { typedef T* type; };

typedef typename add_pointer<int>::type int_pointer;

而在C++11中我们只需要使用C++11的新特性模版别名就可以定义一个add_pointer元函数了，代码变得更简洁了。

template<class T> using add_pointer = T*;

using int_pointer = add_pointer<int>;

在C++11中，元函数由模版类变为模版别名了。C++11中提供了大量元函数在type_traits库中，这样我们不用再自己写了，直接拿过来使用就行了。

C++11中另外的一个新特性variadic template可以作为一个类型容器，我们可以通过variadic templates pack访问模版参数，不需要通过模版递归和特化来访问模版参数。

template<typename... Values> struct meta_list {};
using list_of_ints = meta_list<char, short, int, long>;

template<class List> struct list_size;
template<template<class...> class List, class... Elements>
struct list_size<List<Elements...>>
    :  std::integral_constant<std::size_t, sizeof...(Elements)> {};

constexpr auto size = list_size<std::tuple<int, float, void>>::value;
constexpr auto size1 = list_size<list_of_ints>::value;
constexpr auto size2 = list_size<boost::variant<int, float>>::value;

通过variadic template pack让编译器帮助我们访问类型，比C++98中通过模版递归和特化来访问类型效率更高。

C++11中另外一个新特性constexpr也让我们编写元函数变得更简单了。

在C++98中：

template <int n> struct fact98 {
  static const int value = n * fact98<n - 1>::value;
};
template <> struct fact98<0> {
  static const int value = 1;
};
std::cout << fact98<5>::value << std::endl;

在C++11中：

constexpr int fact11(int n) {
    return n <= 1 ? 1 : (n * fact11(n - 1));
}

我们不再需要通过模版特化和递归来做编译期计算了，我们直接通过新的关键字constexpr来实现编译期计算，它修饰一个函数，表明这个函数是在编译期计算的，这个函数和一个普通函数看起来几乎没有分别，唯一的差别就是多了一个constexpr，比C++98的写法简单多了。

不过在C++11中constexpr的限制比较多，比如说constexpr函数中只能是个表达式，无法使用变量，循环等语句，在C++14中就去掉这个限制了，让我们可以更方便地写编译期计算的函数了。

C++14中的元编程思想

//in c++11
constexpr int fact11(int n) {
  return n <= 1 ? 1 : (n * fact11(n - 1));
}

//in c++14
constexpr int fact14(int n) {
    int s = 1;
    for (int i = 1; i <= n; i++) { s = s * i; }
    return s;
}

可以看到在C++14中我们写constexpr编译期计算的函数时，不必受限于表达式语句了，可以定义变量和写循环语句了，这样也不用通过递归去计算了，直接通过循环语句就可以得到编译期计算结果了，使用起来更方便了。

在C++14中除了constexpr增强之外，更重要的几个影响元编程思想的特性是constexpr, generic lambda, variable template。新标准、新特性会产生新的编程思想，在C++14里元编程的编程思想发生了重大的变化！

在2014年Louis Dionne用C++14写的一个叫Hana的元编程库横空出世，它的出现在C++社区引起震动，因为它所采用的方法不再是经典的模版元的那一套方法了，是真正意义上的函数式编程实现的。模版元在概念上是函数式编程，而Hana是第一次在写法上也变成函数式编程了，这是C++元编程思想的一个重大改变。

Boost.Hana的编程思想

通过一个例子来看Boost.Hana的编程思想：

template <typename T>
struct type_wrapper {
    using type = T;
};

template <typename T>
type_wrapper<T> type{};

//type to value
auto the_int_type = type<int>;

//value to type
using the_real_int_type = decltype(the_int_type)::type;

这里我们定义了一个类型的wraper，里面只有一个子类型，接着定义这个wraper的变量模版，有了这个变量模版，我们就可以很方便的实现type-to-value和value-to-type了。

某个具体类型的变量模版就代表一个值，通过decltype这个值就能得到变量模版的类型了，有了这个变量模版，我们就可以通过Lambda写元函数了，这里的Lambda是C++14中的generic lambda，这个Lambda的参数就是一个变量模版值，在Lambda表达式中，我们可以对获取值的sub type并做转换，然后再返回变换之后的变量模版值。

template <typename T>
type_wrapper<T> type{};

constexpr auto add_pointer = [](auto t) {
    using T = typename decltype(t)::type;
    return type<std::add_pointer_t<T>>; //type to value
};

constexpr auto intptr = add_pointer(type<int>);
static_assert(std::is_same_v<decltype(intptr)::type, int*>); //value to type

这里的add_pointer元函数不再是一个模版类或者模版别名了，而是一个Lambda表达式。这里面关键的两个地方是如何把类型变为值和把值变为类型，通过C++14的变量模版就可以实现这个目标了。

Boost.Hana的目标是通过类型容器融合编译期和运行期计算，替代boost.mpl和boost.fusion！比如下面的例子：

auto animal_types = hana::make_tuple(hana::type_c<Fish*>, hana::type_c<Cat&>, hana::type_c<Dog*>);
auto animal_ptrs = hana::filter(animal_types, [](auto a) {
    return hana::traits::is_pointer(a);
});

static_assert(animal_ptrs == hana::make_tuple(hana::type_c<Fish*>, hana::type_c<Dog*>), "");

auto animals = hana::make_tuple(Fish{ "Nemo" }, Cat{ "Garfield" }, Dog{ "Snoopy" });
auto names = hana::transform(animals, [](auto a) {
    return a.name;
});
assert(hana::reverse(names) == hana::make_tuple("Snoopy", "Garfield", "Nemo"));

我们既可以操作类型容器中的类型，又可以操作类型容器中的运行期的值，Hana可以帮我们很方便地融合编译期与运行期的计算。

Boost.Hana的特点：

• 元函数不再是类或类模版，而是lambda；

• 不再基于类型，而是基于值；

• 没有SFINAE，没有模版递归；

• 函数式编程；

• 代码更容易理解；

• 元编程变得更简单；

• 融合编译期与运行期。

以Boost.Hana为代表的元编程实现不再是经典的type level的思想了，而是以C++14新特性实现的lambda level的函数式编程思想了。

C++17元编程思想

在C++17中，元编程得到了进一步地简化，比如我们之前需要借助模版特化，SFINAE才能实现的编译期选择，现在通过if constexpr就可以很轻松的实现了。

在C++98中：

template<std::size_t I>
auto& get(person& p);

template<>
auto& get<0>(person& p) {
    return p.id;
}

template<>
auto& get<1>(person& p) {
    return p.name;
}

template<>
auto& get<2>(person& p) {
    return p.age;
}

在C++17中：

template<std::size_t I>
auto& get(person& p) {
    if constexpr (I == 0) {
        return p.id;
    }
    else if constexpr (I == 1) {
        return p.name;
    }
    else if constexpr (I == 2) {
        return p.age;
    }
}

这里不再需要模版特化了，也不需要拆分成多个函数了，就像普通的if-else语句一样写编译期选择的代码，简洁易懂！

在C++14中：

template <typename T>
std::enable_if_t<std::is_same_v<T, std::string>, std::string> to_string(T t){
    return t;
}

template <typename T>
std::enable_if_t<!std::is_same_v<T, std::string>, std::string> to_string(T t){
    return std::to_string(t);
}

在C++17中：

template <typename T>
std::string to_string(T t){
    if constexpr(std::is_same_v<T, std::string>)
        return t;
    else
        return std::to_string(t);
}

这里不再需要SFINAE了，同样可以实现编译期选择，代码更加简洁。

C++元编程的库以这些库为代表，这些库代表了C++元编程思想不断演进的一个趋势：

• C++98：boost.mpl，boost.fusion

• C++11：boost.mp11，meta，brigand

• C++14：boost.hana

从C++98到Modern C++，C++新标准新特性产生新的idea，让元编程变得更简单更强大，Newer is Better!

Modern C++元编程应用

编译期检查

元编程的一个典型应用就是编译期检查，这也是元编程最简单的一个应用，简单到用一行代码就可以实现编译期检查。比如我们需要检查程序运行的系统是32位的还是64位的，通过一个简单的assert就可以实现了。

static_assert(sizeof(void *) == 8, "expected 64-bit platform");

当系统为32位时就会产生一个编译期错误并且编译器会告诉你错误的原因。

这种编译期检查比通过#if define宏定义来检查系统是32位还是64位好得多，因为宏定义可能存在忘记写的问题，并不能在编译期就检查到错误，要到运行期才能发现问题，这时候就太晚了。

再看一个例子：

template<typename T, int Row, int Column>
struct Matrix {
    static_assert(Row >= 0, "Row number must be positive.");
    static_assert(Column >= 0, "Column number must be positive.");
    static_assert(Row + Column > 0, "Row and Column must be greater than 0.");
};

在这个例子中，这个Matrix是非常安全的，完全不用担心定义Matrix时行和列的值写错了，因为编译器会在编译期提醒你哪里写错了，而不是等到运行期才发现错误。

除了经常用staticassert做编译期检查之外，我们还可以使用enableif来做编译期检查。

struct A {
void foo(){}
    int member;
};

template<typename Function>
std::enable_if_t<!std::is_member_function_pointer_v<Function>> foo(Function&& f) {
}

foo([] {});  //ok
foo(&A::foo);  //compile error: no matching function for call to 'foo(void (A::*)())'

比如这个代码，我们通过std::enableift来限定输入参数的类型必须为非成员函数，如果传入了成员函数则会出现一个编译期错误。

元编程可以让我们的代码更安全，帮助我们尽可能早地、在程序运行之前的编译期就发现bug，让编译器而不是人来帮助我们发现bug。

编译期探测

元编程可以帮助我们在编译期探测一个成员函数或者成员变量是否存在。

template< class, class = void >
struct has_foo : std::false_type {};

template< class T >
struct has_foo< T, std::void_t<decltype(std::declval<T>().foo())> > :
    std::true_type {};

template< class, class = void >
struct has_member : std::false_type {};

template< class T >
struct has_member< T, std::void_t<decltype(std::declval<T>().member)> > :
    std::true_type {};

struct A {
    void foo(){}
    int member;
};
static_assert(has_foo< A >::value);
static_assert(has_member< A >::value);

我们借助C++17的void_t，就可以轻松实现编译期探测功能了，这里实际上是利用了SFINAE特性，当decltype(std::declval().foo())成功了就表明存在foo成员函数，否则就不存在。

通过编译期探测我们可以很容易实现一个AOP（Aspect Oriented Programming）功能，AOP可以通过一系列的切面帮我们把核心逻辑和非核心逻辑分离。

server.set_http_handler<GET, POST>("/aspect", [](request& req, response& res) {
    res.render_string("hello world");
}, check{}, log_t{});

上面这段代码的核心逻辑就是返回一个hello world，非核心逻辑就是检查输入参数和记录日志，把非核心逻辑分离出来放到两个切面中，不仅仅可以让我们的核心逻辑保持简洁，还可以让我们可以更专注于核心逻辑。

实现AOP的思路很简单，通过编译期探测，探测切面中是否存在before或者after成员函数，存在就调用。

constexpr bool has_befor_mtd = has_before<decltype(item), request&, response&>::value;
if constexpr (has_befor_mtd)
    r = item.before(req, res);

constexpr bool has_after_mtd = has_after<decltype(item), request&, response&>::value;
if constexpr (has_after_mtd)
    r = item.after(req, res);

为了让编译期探测的代码能复用，并且支持可变模版参数，我们可以写一个通用的编译期探测的代码：

#define HAS_MEMBER(member)\
template<typename T, typename... Args>\
struct has_##member\
{\
private:\
      template<typename U> static auto Check(int) -> decltype(std::declval<U>().member(std::declval<Args>()...),                  std::true_type()); \
   template<typename U> static std::false_type Check(...);\
public:\
   enum{value = std::is_same<decltype(Check<T>(0)), std::true_type>::value};\
};

HAS_MEMBER(before)
HAS_MEMBER(after)

具体代码可以参考这里：https://github.com/qicosmos/feather。

注：这段宏代码可以用c++20的std::is_detected替代，也可以写一个C++14/17的代码来替代这个宏：

namespace {
    struct nonesuch {
        nonesuch() = delete;
        ~nonesuch() = delete;
        nonesuch(const nonesuch&) = delete;
        void operator=(const nonesuch&) = delete;
    };

    template<class Default, class AlwaysVoid,
        template<class...> class Op, class... Args>
    struct detector {
        using value_t = std::false_type;
        using type = Default;
    };


    template<class Default, template<class...> class Op, class... Args>
    struct detector<Default, std::void_t<Op<Args...>>, Op, Args...> {
        using value_t = std::true_type;
        using type = Op<Args...>;
    };

    template<template<class...> class Op, class... Args>
    using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;

    template<template<class...> class Op, class... Args>
    using detected_t = typename detector<nonesuch, void, Op, Args...>::type;

    template<class T, typename... Args>
    using has_before_t = decltype(std::declval<T>().before(std::declval<Args>()...));

    template<class T, typename... Args>
    using has_after_t = decltype(std::declval<T>().after(std::declval<Args>()...));
}

template<typename T, typename... Args>
using has_before = is_detected<has_before_t, T, Args...>;

template<typename T, typename... Args>
using has_after = is_detected<has_after_t, T, Args...>;

编译期计算

编译期计算包含了较多内容，限于篇幅，我们重点说一下类型萃取的应用：

• 类型计算；

• 类型推导；

• 类型萃取；

• 类型转换；

• 数值计算：表达式模版，Xtensor，Eigen，Mshadow。

我们可以通过一个function_traits来萃取可调用对象的类型、参数类型、参数个数等类型信息。

template<typename Ret, typename... Args>
struct function_traits_impl<Ret(Args...)>{
public:
    enum { arity = sizeof...(Args) };
    typedef Ret function_type(Args...);
    typedef Ret result_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;
         };

    typedef std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...> tuple_type;
    using args_type_t = std::tuple<Args...>;
};

完整代码可以参考这里：https://github.com/qicosmos/cinatra。

有了这个function_traits之后就方便实现一个RPC路由了，以rest_rpc为例（https://github.com/qicosmos/rest_rpc）：

struct rpc_service {
    int add(int a, int b) { return a + b; }

    std::string translate(const std::string& orignal) {
        std::string temp = orignal;
        for (auto& c : temp) c = toupper(c);
        return temp;
    }
};


rpc_server server;
server.register_handler("add", &rpc_service::add, &rpc_srv);
server.register_handler("translate", &rpc_service::translate, &rpc_srv);

auto result = client.call<int>("add", 1, 2);
auto result = client.call<std::string>("translate", "hello");

RPCServer注册了两个服务函数add和translate，客户端发起RPC调用，会传RPC函数的实际参数，这里需要把网络传过来的字节映射到一个函数并调用，这里就需要一个RPC路由来做这个事情。下面是RestRPC路由的实现：

template<typename Function>
void register_nonmember_func(std::string const& name, const Function& f) {
    this->map_invokers_[name] = { std::bind(&invoker<Function>::apply, f,   std::placeholders::_1,   std::placeholders::_2, std::placeholders::_3) };
}

template<typename Function>
struct invoker {
    static void apply(const Function& func, const char* data, size_t size,
std::string& result) {
    using args_tuple = typename function_traits<Function>::args_tuple;
         msgpack_codec codec;
    auto tp = codec.unpack<args_tuple>(data, size);
         call(func, result, tp);
    }
};

RPCServer注册RPC服务函数的时候，函数类型会保存在invoker中，后面收到网络字节的时候，我们通过functiontraits萃取出函数参数对应的tuple类型，反序列化得到一个实例化的tuple之后就可以借助C++17的std::apply实现函数调用了。详细代码可以参考rest_rpc。

编译期反射

通过编译期反射，我们可以得到类型的元数据，有了这个元数据之后我们就可以用它做很多有趣的事情了。可以用编译期反射实现：

• 序列化引擎；

• ORM；

• 协议适配器。

以序列化引擎iguana（https://github.com/qicosmos/iguana）来举例，通过编译期反射可以很容易的将元数据映射为json、xml、msgpack或其他格式的数据。

struct person{
  std::string  name;
  int          age;
};
REFLECTION(person, name, age)

person p = {"tom", 20};
iguana::string_stream ss;

to_xml(ss, p);
to_json(ss, p);
to_msgpack(ss, p);
to_protobuf(ss, p);

以ORM引擎（https://github.com/qicosmos/ormpp）举例，通过编译期反射得到的元数据可以用来自动生成目标数据库的SQL语句：

ormpp::dbng<mysql> mysql;
ormpp::dbng<sqlite> sqlite;
ormpp::dbng<postgresql> postgres;

mysql.create_datatable<person>();
sqlite.create_datatable<person>();
postgres.create_datatable<person>();

反射将进入C++23标准，未来的C++标准中的反射将更强大和易用。

融合编译期和运行期

运行期和编译期存在一个巨大的鸿沟，而在实际应用中我需要融合编译期与运行期，这时候就需要一个桥梁来连接编译期与运行期。编译期和运行期从概念上可以简单地认为分别代表了type和value，融合的关键就是如何实现type to value以及value to type。

Modern C++已经给我们提供了便利，比如下面这个例子：

auto val = std::integral_constant<int, 5>{};
using int_type = decltype(val);

auto v = decltype(val)::value;

我们可以很方便地将一个值变为一个类型，然后由通过类型获得一个值。接下来我们来看一个具体的例子：如何根据一个运行时的值调用一个编译期模版函数？

template<size_t N>
void fun() {}

void foo(int n) {
    switch (n){
    case 0:
             fun<0>();
      break;
    case 1:
             fun<1>();
      break;
    case 2:
             fun<2>();
      break;
    default:
      break;
        }
}

这个代码似乎很好地解决了这个问题，可以实现从运行期数值到编译期模版函数调用。但是如果这个运行期数值越来越大的时候，我们这个switch就会越来越长，还存在写错的可能，比如调用了foo(100)，那这时候真的需要写100个switch-case吗？所以这个写法并不完美。

我们可以借助tuple来比较完美地解决这个问题：

namespace detail {
    template <class Tuple, class F, std::size_t...Is>
    void tuple_switch(const std::size_t i, Tuple&& t, F&& f, std::index_sequence<Is...>) {
        (void)std::initializer_list<int> {
                (i == Is && (
                        (void)std::forward<F>(f)(std::integral_constant<size_t, Is>{}), 0))...
        };
    }
} // namespace detail

template <class Tuple, class F>
inline void tuple_switch(const std::size_t i, Tuple&& t, F&& f) {
    constexpr auto N =
            std::tuple_size<std::remove_reference_t<Tuple>>::value;

    detail::tuple_switch(i, std::forward<Tuple>(t), std::forward<F>(f),
                         std::make_index_sequence<N>{});
}

void foo(int n) {
    std::tuple<int, int, int> tp;
    tuple_switch(n, tp, [](auto item) {
    constexpr auto I = decltype(item)::value;
         fun<I>();
    });
}

foo(1);
foo(2);

通过一个tuple_switch就可以通过运行期的值调用编译期模版函数了，不用switch-case了。关于之前需要写很长的switch-case语句的问题，也可以借助元编程来解决：

template<size_t... Is>
auto make_tuple_from_sequence(std::index_sequence<Is...>)->decltype(std::make_tuple(Is...)) {
        std::make_tuple(Is...);
}

template<size_t N>
constexpr auto make_tuple_from_sequence()->decltype(make_tuple_from_sequence(std::make_index_sequence<N>{})) {
        return make_tuple_from_sequence(std::make_index_sequence<N>{});
}

void foo(int n) {
        decltype(make_tuple_from_sequence<100>()) tp;  //std::tuple<int, int, …, int>
        tuple_switch(n, tp, [](auto item) {
        constexpr auto I = decltype(item)::value;
                 fun<I>();
        });
}

foo(98);
foo(99);

这里的decltype(maketuplefrom_sequence<100>())会自动生成一个有100个int的tuple<int,...,int>辅助类型，有了这个辅助类型，我们完全不必要去写长长的switch-case语句了。

有人也许会担心，这里这么长的tuple<int,...,int>会不会生成100个Lambda实例化代码？这里其实不用担心，因为编译器可以做优化，优化的情况下只会生成一次Lambda实例化的代码，而且实际场景中不可能存在100个分支的代码。

接口的泛化与统一

元编程可以帮助我们融合底层异构的子系统、屏蔽接口或系统的差异、提供统一的接口。

以ORM为例：

MySQL connect

mysql_real_connect(handle, "127.0.0.1", "feather", "2018", "testdb", 0, nullptr, 0);

PostgreSQL connect

PQconnectdb("host=localhost user=127.0.0.1 password=2018 dbname=testdb");

Sqlite connect

sqlite3_open("testdb", handle);

ORM unified connect interface

ORM::mysql.connect("127.0.0.1", “feather", “2018", "testdb");
ORM::postgres.connect("127.0.0.1", “feather", “2018", "testdb");
ORM::sqlite.connect("testdb");

不同的数据库的C connector相同功能的接口是完全不同的，ormpp库（https://github.com/qicosmos/ormpp）要做的一件事就是要屏蔽这些接口的差异，让用户可以试用统一的接口来操作数据库，完全感受不到底层数据库的差异。

元编程可以帮助我们实现这个目标，具体思路是通过可变参数模版来统一接口，通过policy-base设计和variadic templates来屏蔽数据库接口差异。

template<typename DB>
class dbng{
template <typename... Args>
bool connect(Args&&... args){
    return  db_.connect(std::forward<Args>(args)...);
}

template<typename... Args>
bool connect(Args... args) {
if constexpr (sizeof...(Args)==5) {
    return std::apply(&mysql_real_connect, std::make_tuple(args...);
}
else if constexpr (sizeof...(Args) == 4) {//postgresql}
else if constexpr (sizeof...(Args) == 2) {//sqlite}
}

这里通过connect(Args... args)统一连接数据库的接口，然后再connect内部通过if constexpr和变参来选择不同的分支。if constexpr加variadic templates等于静态多态，这是C++17给我们提供的一种新的实现静态多态方法。

这样的好处是可以通过增加参数或修改参数类型方式来扩展接口，没有继承，没有SFINAE，没有模版特化，简单直接。

消除重复（宏）

很多人喜欢用宏来减少手写重复的代码，比如下面这个例子，如果对每个枚举类型都写一个写到输出流里的代码段，是重复而繁琐的，于是就通过一个宏来消除这些重复代码（事实上，这些重复代码仍然会生成，只不过由编译器帮助生成了）。

#define ENUM_TO_OSTREAM_FUNC(EnumType)  \
      std::ostream& operator<<(std::ostream& out_stream, const EnumType& x) { \
        out_stream << static_cast<int>(x);    \                                                      
        return out_stream;        \                                                                                      
      }

enum class MsgType { Connected, Timeout };
enum class DataType {Float, Int32};
ENUM_TO_OSTREAM_FUNC(MsgType);
ENUM_TO_OSTREAM_FUNC(DataType);

这看似是使用宏的合适场景，但是宏最大的问题是代码无法调试，代码的易读性差，但是用元编程，我们不用写这个宏了，也不用去写宏定义了。

template<typename T, typename = 
typename std::enable_if<std::is_enum<T>::value>::type>
std::ostream& operator<<(std::ostream& out_stream, T x) {
    out_stream << static_cast<int>(x);
    return out_stream;
}

元编程比宏更好地解决了问题。

再看一个宏的例子：

#define CALL(name, ...)                       \
      do {                                    \
           result ret = func(name);           \
           if (ret == 0) {                    \
                    __VA_ARGS__;              \
                  do_something(name);         \
        }                                     \
         else {                               \
                  do_something (name);        \
        }                                     \
      } while (0)

CALL("root", func1(root_path));
CALL("temp", func2(temp_path));

这也是宏使用的一个典型场景——复用代码段。当很多代码段都是类似的时候，只有一点点代码不同，那么就可以通过宏来避免手写这些重复代码。上面这个宏把不同的代码段func1(rootpath)，func2(temppath)作为参数传进来，从而复用这个代码段。

我们可以通过一个泛型函数来替换这个宏：

template<typename Self, typename F>
void Call(const std::string& name, Self * self, F f) {
    auto ret = foo(name);
    if (ret == 0) {
                 (self >*f)(name);
                 do_something(name);
         }
    else {
                 do_something(name);
        }
}

事实上大部分宏能做的，元编程能做得更好、更完美！

接口易用和灵活性

还是以rest_rpc为例，我们可以注册任意类型的RPC函数，不管参数个数和类型是否相同、返回类型是否相同，这让我们的注册接口非常易用和灵活。

struct dummy{
        int add(connection* conn, int a, int b) { return a + b; }
};

int add(connection* conn, int a, int b) { return a + b; }

rpc_server server(8080, 4);

dummy d;
server.register_handler("a", &dummy::add, &d);
server.register_handler("b", add);
server.register_handler("c", [](connection* conn) {});
server.register_handler("d", [](connection* conn, std::string s) {
        return s;
});

这里我们使用元编程帮我们擦除了函数类型：

template<typename Function >
void register_nonmember_func(std::string const& name, const Function& f) {
    this->map_invokers_[name] = { std::bind(&invoker<Function>::apply, f,   std::placeholders::_1,   std::placeholders::_2, std::placeholders::_3) };
}

template<typename Function>
struct invoker {
    static void apply(const Function& func, const char* data, size_t size,
std::string& result) {
    using args_tuple = typename function_traits<Function>::args_tuple;
         msgpack_codec codec;
    auto tp = codec.unpack<args_tuple>(data, size);
         call(func, result, tp);
    }
};

typename Function做了类型擦除，typename functiontraits::argstuple帮我们还原了类型。

再来看另外一个例子，cinatra（https://github.com/qicosmos/cinatra）注册路由函数的例子:

server.set_http_handler<GET>("/a", &person::foo);

server.set_http_handler<GET, POST>("/b", &person::foo, log_t{});

server.set_http_handler<GET, POST, HEAD>("/c", &person::foo, log_t{}, check{});

server.set_http_handler<GET>("/d", &person::foo, log_t{}, check{}, enable_cache{ false });

server.set_http_handler<GET>("/e", &person::foo, log_t{}, enable_cache{ false }, check{});

server.set_http_handler<POST>("/f", &person::foo, enable_cache{ false }, log_t{}, check{});

这个例子中，用户可以增加任意切面，还可以增加缓存参数，切面和缓存参数的顺序可以是任意的，这样完全消除了用户使用接口时需需要注意参数顺序的负担，完全是自由灵活的。这里并没有使用多个重载函数做这个事情，而是借助元编程，把缓存参数过滤出来，这样就可以无视外面传入参数的顺序了。

过滤参数的代码如下：

template<http_method... Is, typename Function, typename... AP>
void set_http_handler(std::string_view name, Function&& f, AP&&... ap) {
    if constexpr(has_type<enable_cache<bool>,   std::tuple<std::decay_t<AP>...>>::value) {
        auto tp = filter<enable_cache<bool>>(std::forward<AP>(ap)...);
        std::apply(f, std::move(tp));
    }
    else {
        http_router_.register_handler<Is...>(name, std::forward<Function>(f),  std::forward<AP>(ap)...);
    }
}

template <typename T, typename Tuple>
struct has_type;

template <typename T, typename... Us>
struct has_type<T, std::tuple<Us...>> : std::disjunction<std::is_same<T, Us>...> {};

template< typename T>
struct filter_helper{
    static constexpr auto func(){
        return std::tuple<>();
    }

    template< class... Args >
    static constexpr auto func(T&&, Args&&...args){
        return filter_helper::func(std::forward<Args>(args)...);
    }

    template< class X, class... Args >
    static constexpr auto func(X&&x, Args&&...args){
        return std::tuple_cat(std::make_tuple(std::forward<X>(x)), filter_helper::func(std::forward<Args>(args)...));
    }
};

这里通过C++17的std::disjunction来判断是否存在某个类型，通过if constexpr实现编译期选择。

总结

C++新标准给元编程带来了巨大的改变，不仅仅让元编程变得简单好写了，还让它变得更加强大了，帮助我们优雅地解决了很多实际的问题。文中列举到的元编程应用仅仅是冰山一角，还有很多其他方面的应用。

本文内容为作者自 2018 中国 C++大会演讲内容整理而来。

作者：祁宇，Modern C++开源社区purecpp.org创始人，《深入应用 C++11》作者，开源库cinatra、feather作者，热爱开源，热爱Modern C++。乐于研究和分享技术，多次在国际C++大会(cppcon)做演讲。

---

 热 文 推 荐 

print_r('点个好看吧！');
var_dump('点个好看吧！');
NSLog(@"点个好看吧！");
System.out.println("点个好看吧！");
console.log("点个好看吧！");
print("点个好看吧！");
printf("点个好看吧！\n");
cout << "点个好看吧！" << endl;
Console.WriteLine("点个好看吧！");
fmt.Println("点个好看吧！");
Response.Write("点个好看吧！");
alert("点个好看吧！")
echo "点个好看吧！"

点击“阅读原文”，打开 CSDN App 阅读更贴心！

喜欢就点击“好看”吧！