從 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)做演講。

喜歡這篇文章嗎？立刻分享出去讓更多人知道吧！