最近在学习 C++ Template 这本书，补齐了一些模板元编程相关的信息，后续会持续更新。
函数模板
推断函数模板的返回值
假设我们希望计算两个两个类型不相同的变量中的最大值（如 1u 和 2.0f），我们要如何定义函数模板？
// since c++ 14
template <typename T1, typename T2> auto max(T1 x, T2 y) {
return x > y ? x : y;
}
// here x's type is float
auto x = ::max(1u, 2.0f);
从 c++ 14 开始，我们可以使用 auto 让编译器帮我们自动计算返回值的类型，然而在此之前，我们必须使用 decltype 或 common_type 这样的工具来告诉编译器，我们需要返回什么类型：
// c++ 11
template <typename T1, typename T2>
auto max(T1 x, T2 y) -> decltype(x > y ? x : y) {
return x > y ? x : y;
}
// equal to
template <typename T1, typename T2>
auto max(T1 x, T2 y) -> decltype(true ? x : y) {
return x > y ? x : y;
}
然而，上述的代码可能面临一些严重的问题。在一些特殊场景下，返回值可能为引用，这时候需要使用类型萃取（type trait）std::decay
// c++ 11
#include <type_traits>
template <typename T1, typename T2>
auto max(T1 a, T2 b) -> typename std::decay<decltype(true ? a : b)>::type {
return b < a ? a : b;
}
// since c++ 14, simplified
template <typename T1, typename T2>
auto max(T1 a, T2 b) -> std::decay_t<decltype(true ? a : b)> {
return b < a ? a : b;
}
注意到 c++ 14 对 typename std::decay<decltype(true ? a : b)>::type 这样的写法进行了简化。
这边顺便回顾一下 auto 和 decltype 的区别：
auto 在大部分场景下和模板类型 T 的行为是一致的，会对推导的类型进行退化（decay）。此处的退化是指：
- 去除
const，volatile等关键字； - 去除引用
- 将数组退化成指针
decltype 则是老老实实地获取类型，不会进行退化操作。有一个比较有意思的特殊场景：
// will return int &
auto f(int a) -> decltype((a)) { return a; }
虽然上述的用法是不正确的（返回了垂悬引用，dangling reference），但是能表明 decltype 会把 () 括起来的变量视作引用。
言归正传，之前的写法用 decltype 虽然能解决问题，但是未免太麻烦了点，我们可以用 std::common_type_t<T1, T2, ...> 来解决这个问题：
// since c++ 14
template <typename T1, typename T2>
auto max(T1 a, T2 b) -> std::common_type_t<T1, T2> {
return b < a ? a : b;
}
还有一种写法，实际上 c++ 在实例化模板时，只要能保证能推断出所有的类型即可，我们可以定义一个返回类型 RT:
template <typename RT, typename T1, typename T2>
RT max(T1 a, T2 b) {
return b < a ? a : b;
}
auto x = ::max<float>(1u, 2.0f);
这样只需要指定 RT 即可，因为 T1 和 T2 的类型对于编译器而言是已知的。但是下面的写法就会出错：
template <typename T1, typename T2, typename RT>
RT max(T1 a, T2 b) {
return b < a ? a : b;
}
auto x = ::max<unsigned int, float>(1u, 2.0f);
报错信息为：
Candidate template ignored: couldn’t infer template argument ‘RT’
编译器无法自动推断 RT 的类型，除非使用上述的 auto。
c++ 还支持模板类型的默认值，比如常用的 std::priority_queue 实际上有 3 个模板类型。
类模板
c++ 支持使用基础的数值类型（double 除外）作为模板参数：
template <typename T, size_t MaxSize> class Stack {
array<T, MaxSize> elements;
Stack(T first) : elements({first}) {}
};
虽然不支持直接使用字符串常量，但是可以通过定义一个变量来解决
template <char const *name> class MyClass {
...
};
MyClass<"hello"> x; // ERROR: string literal "hello" not allowed
extern char const s03[] = "hi"; // external linkage
char const s11[] = "hi"; // internal linkage
int main() {
MyClass<s03> m03; // OK (all versions)
MyClass<s11> m11; // OK since C++11
static char const s17[] = "hi"; // no linkage
MyClass<s17> m17; // OK since C++17
}
推断指引（Deduction Guides）
template <typename T> class Stack {
vector<T> elements;
public:
Stack() = default;
Stack(T first) : elements({first}) {}
};
Stack(char const *)->Stack<std::string>;
Stack s("123");
如果没有 Stack(char const *)->Stack<std::string>;，s 将被推导为 Stack<const char *>。
Concept
template <typename T> struct AccumulationTraits;
template <> struct AccumulationTraits<int> {
using AccT = int;
static AccT constexpr zero = 0;
};
template <> struct AccumulationTraits<string> {
using AccT = string;
// support since c++ 17
inline static AccT const zero = "";
};
template <typename T> auto accum(T begin, T end) {
using AccT = AccumulationTraits<T>::AccT;
AccT total = AccumulationTraits<T>::zero;
for (T i = begin; i <= end; i++) {
total += i;
}
return total;
}
int main(int, char **) {
auto total = accum(1, 100);
cout << total << endl;
}
template <typename T>
concept Addable = requires(T a, T b) {
{ a + b } -> std::same_as<T>;
};
template <typename T>
requires Addable<T> && std::is_arithmetic_v<T>
T accum(T begin, T end) {
T total{};
for (T i = begin; i <= end; i++) {
total += i;
}
return total;
}
此处也可以把 typename 替换成 Addable 之类的 concept。和 rust 的 trait 语法非常类似。