模板元编程 - shy-blog

IMPORTANT
本文不再介绍 C++ 模板的基础用法．

模板也是「函数」#

我们可以把模板也看成一种「函数」，这个「函数」的输入输出不仅限于值，还可以是类型，甚至「函数」．

案例 1
统计若干类型的总大小．

1
#include <print>
2
#include <vector>
3

4

5
template <class ...T>
6
struct get_size {};
7

8

9
template <>
10
struct get_size<> { static constexpr size_t value = 0; };
11

12

13
template <class T, class ...U>
14
struct get_size<T, U...> {
15
  static constexpr size_t value = sizeof(T) + get_size<U...>::value;
16
};
17

18
int main() {
19
  size_t N = get_size<int[1000], std::vector<int>, std::string>::value;
20
  std::println("1000 * 4 + 24 + 24 = {}", N);
21
}

1
1000 * 4 + 24 + 24 = 4048

C++ 提供了能封装输出值的类型，不用我们手搓 value：

1
template <class ...T>
2
struct get_size {};
3

4
template <>
5
struct get_size<>
6
  : std::integral_constant<size_t, 0> {};
7

8
template <class T, class ...U>
9
struct get_size<T, U...>
10
  : std::integral_constant<size_t, sizeof(T) + get_size<U...>::value> {};

有没有函数式传参的写法？

错误的写法

1
constexpr size_t get_size() { return 0; }
2

3
template <class T, class ...U>
4
constexpr size_t get_size(T t, U ...u) {
5
  return sizeof(t) + get_size(u...);
6
}
7

8
struct TypeA {};
9
struct TypeB { TypeB(TypeB &&) = delete; };
10

11
int main() {
12

13
  auto ret = get_size(std::declval<TypeA>(), std::declval<TypeB>());
14
}

想要保持这种函数式写法，关键是不要真的传对象，而是传类型信息．

1
template <class T>
2
struct Dummy { using type = T; };
3

4
template <class ...T>
5
constexpr size_t get_size(Dummy<T> ...t) {
6

7
  if constexpr (sizeof...(T) == 0) {
8
    return 0;
9
  } else {
10
    return (sizeof(t) + ...); // 折叠表达式实现递归
11
  }
12
}
13

14
int main() {
15

16
  auto ret = get_size(Dummy<TypeA>{}, Dummy<TypeB>{});
17
}

关于 constexpr 函数
若 constexpr 函数中存在无法在编译期求值的参数，则 constexpr 函数和普通函数一样在运行时求值，此时的返回值不是常量表达式．
如果想强制要求编译时求值，可以使用 C++20 的 consteval，运行时求值将报错．

二元 fold-expression 可以规定 sizeof...(T) 为 0 时的递归终止值，写法更简洁．另外自 C++20 开始，std::type_identity 可以代替手写 Dummy 包装类．

1
template <class ...T>
2
consteval size_t get_size(std::type_identity<T> ...t) {
3
  return (sizeof(t) + ... + 0);
4
}
5

6

7
template <class T>
8
constexpr std::type_identity<T> tag{};
9

10
TypeA a{};
11
auto ret = get_size(tag<decltype(a)>, tag<TypeB>);

也可以使用模板显式传参的函数式写法：

1
template <class ...T>
2
consteval size_t get_size() { return (sizeof(T) + ... + 0); }
3

4
auto ret = get_size<TypeA, TypeB>();

案例 2
实现 get_type<T, I>，要求：

如果 T 为 std::tuple<>，返回 void；

否则，如果 T 为 std::tuple<T0, ..., TN>：

如果 0 <= I && I <= N 为 true，返回 TI；

否则，返回 void；

否则，返回 void．

1
#include <tuple>
2

3
template <class T, size_t I>
4
struct get_type { using type = void; };
5

6
template <size_t I>
7
struct get_type<std::tuple<>, I> { using type = void; };
8

9
template <class T0, class ...Ts>
10
struct get_type<std::tuple<T0, Ts...>, 0> { using type = T0; };
11

12
template <class T0, class ...Ts, size_t I>
13
struct get_type<std::tuple<T0, Ts...>, I> {
14
  // C++20 可以省略待决名的 typename
15
  using type = typename get_type<std::tuple<Ts...>, I - 1>::type;
16
};
17

18
int main() {
19
  using tup = std::tuple<int, float, bool, char, void *>;
20
  using ret0 = get_type<tup, 0>::type; // int
21
  using ret1 = get_type<tup, 1>::type; // float
22
  using ret2 = get_type<tup, 2>::type; // bool
23
  using ret3 = get_type<tup, 3>::type; // char
24
  using ret4 = get_type<tup, 4>::type; // void *
25
}

待决名的 typename 何时可以省略
自 C++20 开始，待决名的消歧义符 typename 大部分都可以省略，大致除了：

非类型模板形参的默认值表达式中，如 template <class T, auto val = typename T::val_type{}>，即 template <class T, T::val_type val = typename T::val_type{}>；

模板实参类型，如 using t = Tup<typename Tmpl<Ts>::type...>;；

函数形参类型，如 void func(typename T::val_type x) {...}；

在函数或者块作用域内变量/函数声明的类型，如 void func() { typename T::val_type val; }、void func() { typename T::val_type gunc(); }．

函数式写法：

1
template <class T, size_t I>
2
consteval auto get_type_impl(
3
  std::type_identity<T>,
4
  std::integral_constant<size_t, I>
5
) {
6
  return std::type_identity<void>{};
7
}
8

9
template <class T0, class ...Ts, size_t I>
10
consteval auto get_type_impl(
11
  std::type_identity<std::tuple<T0, Ts...>>,
12
  std::integral_constant<size_t, I>
13
) {
14
  if constexpr (I == 0) {
15
    return std::type_identity<T0>{};
16
  } else {
17
    return get_type_impl(
18
      std::type_identity<std::tuple<Ts...>>{},
19
      std::integral_constant<size_t, I - 1>{}
20
    );
21
  }
22
}
23

24
template <class T, size_t I>
25
using get_type = decltype(get_type_impl(
26
  std::type_identity<T>{},
27
  std::integral_constant<size_t, I>{}
28
))::type;
29

30
int main() {
31
  using tup = std::tuple<int, float, char>;
32
  using ret0 = get_type<tup, 0>; // int
33
  using ret1 = get_type<tup, 1>; // float
34
  using ret2 = get_type<tup, 2>; // char
35
  using ret3 = get_type<tup, 3>; // void
36
}

也可以不包装整型参数，从函数形参转移到模板形参：

1
template <size_t I, class T>
2
consteval auto get_type(std::type_identity<T>) {
3
  return std::type_identity<void>{};
4
}
5

6
template <size_t I, class T0, class ...Ts>
7
consteval auto get_type(std::type_identity<std::tuple<T0, Ts...>>) {
8
  if constexpr (I == 0) {
9
    return std::type_identity<T0>{};
10
  } else {
11
    return get_type<I - 1>(std::type_identity<std::tuple<Ts...>>{});
12
  }
13
}
14

15
int main() {
16
  using tup = std::tuple<int, float, char>;
17
  using ret0 = decltype(get_type<0>(std::type_identity<tup>{}))::type; // int
18
  using ret1 = decltype(get_type<1>(std::type_identity<tup>{}))::type; // float
19
  using ret2 = decltype(get_type<2>(std::type_identity<tup>{}))::type; // char
20
  using ret3 = decltype(get_type<3>(std::type_identity<tup>{}))::type; // void
21
}

包索引
C++26 Pack Indexing 可以避免递归元编程：
1
template <size_t I, class ...Ts>
2
consteval auto get_type(std::type_identity<std::tuple<Ts...>>) {
3
  if constexpr (I < sizeof...(Ts)) {
4
    return std::type_identity<Ts...[I]>{};
5
  } else {
6
    return std::type_identity<void>{};
7
  }
8
}
包索引表达式 ...[] 支持模板参数包、函数参数包、结构化绑定包、lambda 初始化捕获包．

案例 3
现有类型 Tup<T1, ..., TN>，映射 Tmpl: T -> U．实现模板 mapping，要求：

返回 Tup<Tmpl<T0>, ..., Tmpl<TN>>．

1
#include <variant>
2

3

4
template <template <class> class Tmpl, class Tup>
5
struct mapping {};
6

7
template <
8
  template <class> class Tmpl,
9
  template <class ...> class Tup,
10
  class ...Ts
11
> struct mapping <
12
  Tmpl,
13
  Tup<Ts...>
14
> {
15
  using type = Tup<typename Tmpl<Ts>::type...>;
16
};
17

18
template <class T>
19
struct copy10 { using type = T[10]; };
20

21
int main() {
22
  using t = std::variant<int, char, bool>;
23

24
  using result_t = mapping<copy10, t>::type;
25
}

案例 4
实现模板 array_wrapper: N -> (Tmpl: T -> T[N])．

1
#include <tuple>
2

3
// mapping 实现
13 collapsed lines
4
template <template <class> class Tmpl, class Tup>
5
struct mapping {};
6

7
template <
8
  template <class> class Tmpl,
9
  template <class ...> class Tup,
10
  class ...Ts
11
> struct mapping <
12
  Tmpl,
13
  Tup<Ts...>
14
> {
15
  using type = Tup<typename Tmpl<Ts>::type...>;
16
};
17

18
template <size_t N>
19
struct array_wrapper {
20

21
  template <class T>
22
  struct Tmpl { using type = T[N]; };
23
};
24

25
int main() {
26
  using t = std::tuple<int, char[10], bool>;
27

28
  using result_t = mapping<array_wrapper<7>::Tmpl, t>::type;
29
}

type_traits#

标准库提供了许多很有用的「函数」，不用我们手搓．

对于大多数操作，相应的 trait 有 noexcept 的版本，如 std::is_invocable_v<T, Args...> 对应于 std::is_nothrow_invocable_v<T, Args...>．

对于含特殊成员函数的类型，相应的 trait 有 trivial 的版本，如 std::is_constructible_v<T, Args...> 对应于 is_trivially_constructible_v<T, Args...>．

类型判断#

类别#

Traits	Desc
`std::is_fundamental_v<T>`	检查 `T` 是否为基本类型 ¹
`std::is_void_v<T>`	检查 `T` 是否为 `void`
`std::is_null_pointer_v<T>`	检查 `T` 是否为 `std::nullptr_t` ²
`std::is_arithmetic_v<T>`	检查 `T` 是否为算术类型 ³
`std::is_integral_v<T>`	检查 `T` 是否为整型 ⁴
`std::is_floating_point_v<T>`	检查 `T` 是否为浮点类型
`std::is_enum_v<T>`	检查 `T` 是否为枚举类型
`std::is_pointer_v<T>`	检查 `T` 是否为指针类型 ⁵
`std::is_member_object_pointer_v<T>`	检查 `T` 是否为成员变量指针类型
`std::is_member_function_pointer_v<T>`	检查 `T` 是否为成员函数指针类型
`std::is_reference_v<T>`	检查 `T` 是否为引用类型
`std::is_lvalue_reference_v<T>`	检查 `T` 是否为左值引用类型
`std::is_rvalue_reference_v<T>`	检查 `T` 是否为右值引用类型

属性#

Traits	Desc
`std::is_const_v<T>`	检查 `T` 是否带有 `const` 限定
`std::is_volatile_v<T>`	检查 `T` 是否带有 `volatile` 限定
`std::is_empty_v<T>`	检查 `T` 是否为空类型 ⁶
`std::is_polymorphic_v<T>`	检查 `T` 是否为多态类
`std::is_abstract_v<T>`	检查 `T` 是否为抽象类
`std::is_final_v<T>`	检查 `T` 是否被 `final` 修饰
`std::is_trivially_copyable_v<T>`	检查 `T` 是否为可平凡复制类型 ⁷
`std::is_trivial_v<T>`	检查 `T` 是否为平凡类 ⁸
`std::is_standard_layout_v<T>`	检查 `T` 成员的内存布局是否为标准布局 ⁹
`std::is_aggregate_v<T>`	检查 `T` 是否为聚合类型 ¹⁰
`std::is_scoped_enum_v<T>`	检查 `T` 是否为作用域枚举类型
`std::is_signed_v<T>`	检查 `T` 是否为有符号的算术类型
`std::is_unsigned_v<T>`	检查 `T` 是否为无符号的算术类型
`std::is_bounded_array_v<T>`	检查 `T` 是否为已知大小的数组类型
`std::is_unbounded_array_v<T>`	检查 `T` 是否为未知大小的数组类型

可支持的操作#

Traits	Desc
`std::is_swappable_with_v<T, U>`	检查 `T` 和 `U` 是否可交换 ¹¹
`std::is_swappable_v<T>`	检查 `T` 之间是否可交换 ¹²
`std::is_constructible_v<T, Args...>`	检查 `Args...` 能否构造出 `T` ¹³
`std::is_default_constructible_v<T>`	检查 `T` 能否默认构造
`std::is_copy_constructible_v<T>`	检查 `T` 能否拷贝构造
`std::is_move_constructible_v<T>`	检查 `T` 能否移动构造
`std::is_assignable_v<T, U>`	检查 `U` 能否赋值给 `T` ¹⁴
`std::is_copy_assignable_v<T>`	检查 `T` 能否拷贝赋值
`std::is_move_assignable_v<T>`	检查 `T` 能否移动赋值
`std::is_destructible_v<T>`	检查 `T` 能否析构 ¹⁵
`std::has_virtual_destructor_v<T>`	检查 `~T()` 是否为虚函数
`std::is_invocable_v<T, Args...>`	检查能否以参数类型 `Args...` 调用 `T` ¹⁶
`std::is_invocable_r_v<Ret, T, Args...>`	同上，并检查返回类型是否为 `Ret`

类型关系#

Traits	Desc
`std::is_same_v<T, U>`	检查 `T`, `U` 是否相同 ¹⁷
`std::is_convertible_v<From, To>`	检查 `From` 能否隐式转换 ¹⁸ 成 `To` ¹⁹
`std::is_base_of_v<Base, Derived>`	检查 `Base` 是否为 `Derived` 的基类
`std::is_virtual_base_of_v<Base, Derived>` (C++26)	检查 `Base` 是否为 `Derived` 的虚基类
`std::is_layout_compatible_v<T, U>`	检查 `T`, `U` 在内存布局上是否兼容
`std::is_pointer_interconvertible_base_of_v<B, D>`	检查 `D ` 能否安全转成 `B ` ²⁰
`std::is_pointer_interconvertible_with_class(M S::*mp)`	检查 `S ` 能否安全转成 `M ` ²¹

类型查询#

Traits	Desc
`std::alignment_of_v<T>`	查询 `T` 的对齐字节数，即 `alignof(T)`
`std::rank_v<T>`	查询 `T` 作为多维数组时的维数
`std::extent_v<T, N>`	查询 `T` 作为多维数组时在第 `N` 维的元素数量 ²²
`std::invoke_result_t<F, Args...>`	查询以参数类型 `Args...` 调用 `T` 返回的类型

类型处理#

Traits	Desc
`std::add_const_t<T>`	`T -> const T`
`std::add_volatile_t<T>`	`T -> volatile T`
`std::add_cv_t<T>`	`T -> const volatile T`
`std::add_lvalue_reference_t<T>`	`T -> T &`
`std::add_rvalue_reference_t<T>`	`T -> T &&`
`std::add_pointer_t<T>`	`T -> T *`
`std::remove_const_t<T>`	`const T -> T`
`std::remove_volatile_t<T>`	`volatile T -> T`
`std::remove_cv_t<T>`	`const volatile T -> T`
`std::remove_reference_t<T>`	`T &/&& -> T`
`std::remove_cvref_t<T>`	`const volatile T &/&& -> T`
`std::unwrap_reference_t<T>`	`std::reference_wrapper<T>/T -> T/T`
`std::unwrap_ref_decay_t<T>`	`std::reference_wrapper<T>/T -> T/std::decay_t<T>`
`std::decay_t<T>`	`U[N] -> U ` / `U(...) -> U()(...)` / `cv U& -> U`
`std::remove_extent_t<T[N]>`	`T[N] -> T` 移除一个维度
`std::remove_all_extents_t<T[I]...[N]>`	`T[I]...[N] -> T` 移除所有维度
`std::remove_pointer_t<T *>`	`T * -> T`，非指针类型 `T -> T`
`std::common_reference_t<T...>`	转换成 `T...` 的公共类型
`std::enable_if_t<bool, T>`	`T -> T/`，若 `false` 则代换失败，用于 SFINAE
`std::conditional_t<bool, T, F>`	`T -> T/F`
`std::void_t<T...>`	`T... -> void`，用于 SFINAE
`std::type_identity_t<T>`	`T -> T`，用于非推断语境

Trait 运算#

Traits	Desc
`std::integral_constant<T, v>`	把 `v` 封装进 `static constexpr T value`，包装输出
`std::bool_constant<b>`	`std::integral_constant<bool, b>`
`std::true_type / std::false_type`	`std::bool_constant<true / false>`
`std::conjunction_v<B...>`	对 `B...` 进行逻辑合取 ²³
`std::disjunction_v<B...>`	对 `B...` 进行逻辑析取 ²⁴
`std::negation_v<B>`	对 `B` 进行逻辑非 ²⁵

约束类型#

利用 SFINAE 约束类型#

在模板实参推导或函数类型推导中，代换失败并不是错误，编译器仅在重载集中抛弃该特化，不会编译失败．在 C++20 之前，我们可以利用这一点对模板类型参数进行约束．

这里的代换失败，发生在 immediate context 中，即

模板函数模板形参中的默认实参类型/表达式

模板函数形参类型

模板函数返回值类型

模板类模板形参中的默认实参类型/表达式

模板类模板参数列表里的类型/表达式

函数模板签名里直接写到的类型/表达式都会出现在 immediate context．在这个语境因代换失败发生的错误，才被称为 SFINAE error．如果是触发了别的模板实例化、隐式成员生成等连锁反应而间接导致的错误是 hard error (会导致编译错误)．

最经典的例子就是 <..., class = typename B<T>::type>，要想取出 type，必须实例化 B<T>，一旦实例化失败 (比如 B<T> 不含 type)，则发生 hard error．

案例 1
对 template <size_t N> void foo() {} 中的 N 约束：

N 为偶数

根据 SFINAE error 触发的位置和方式，可以有下面几种写法：

1
// 1
2
template <size_t N>
3
void foo(char (*)[N % 2 == 0] = nullptr) {
4
  std::println("N is even");
5
}
6

7
// 2
8
template <size_t N>
9
void foo(std::enable_if_t<N % 2 == 0, int> = 0) {
10
  std::println("N is even");
11
}
12

13
// 3
14
template <size_t N>
15
auto foo() -> decltype(std::declval<int[N % 2 == 0]>(), void()) {
16
  std::println("N is even");
17
}
18

19
// 4
20
template <size_t N, std::enable_if_t<N % 2 == 0, int> = 0>
21
void foo() {
22
  std::println("N is even");
23
}

利用 Concept 约束类型#

CRTP#

CRTP (Curiously Recurring Template Pattern) 可以在编译期间把派生类的类型作为模板参数传递给基类．

实现「静态多态」/「接口约定」#

所谓「静态多态」就是在编译期确定行为绑定，通过统一接口适配不同类型的具体实现．函数重载就是一种「静态多态」．

CRTP 通过模板参数将派生类型注入基类，使得基类能在编译期调用派生类的具体实现，从而实现基类定义接口、派生类提供实现的「静态多态」．

CRTP 让派生类的基类各不相同，失去了在抽象层处理的能力，比如将不同派生类型的对象放入基类容器里、通过基类指针调用具体派生类实现等；而动态多态就可以，并能在运行时确定具体派生类型，从而调用具体派生类的实现．

另一种角度
上面是网上很多人使用的表述．也可以这么认为：CRTP 起到使不同类存在若干相同接口的成员函数的约定作用，没有什么继承关系．

1
template <class T>
2
class Weapon {
3
protected:
4
  float power;
5

6
public:
7
  void attack() {
8
    auto that = static_cast<T*>(this);
9
    if (that->can_level_up()) {
10
      that->fix_impl();
11
      power += that->value;
12
    }
13
    that->attack_impl();
14
  }
15

16
  void fix() {
17
    auto that = static_cast<T*>(this);
18
    that->fix_impl();
19
  }
20
};
21

22
class Bow : public Weapon<Bow> {
23
  friend class Weapon<Bow>;
24
protected:
25
  int value;
26
public:
27
  bool can_level_up() { /* ... */ }
28
  void fix_impl() { /* ... */ }
29
  void attack_impl() { /* ... */ }
30
};
31

32
class Gun : public Weapon<Gun> {
33
  friend class Weapon<Gun>;
34
protected:
35
  int value;
36
public:
37
  bool can_level_up() { /* ... */ }
38
  void fix_impl() { /* ... */ }
39
  void attack_impl() { /* ... */ }
40
};
41

42
template <class T>
43
void fix_weapon(Weapon<T> &wp) { wp.fix(); }
44

45
int main() {
46

47
  std::vector<std::unique_ptr<Weapon>> wps;
48
}

C++23 可以向非静态成员函数显式传入对象自身，在此之前都是通过隐式传入 this 指针实现的．

1
struct A {
2
  void f(int x, int y) const;             // void f(int, int) const &;
3
  void g(float x, bool y);                // void g(float, bool) &;
4

5
  void func(this A &self, int x);         // void func(int) &;
6
  void func(this A const &self, int x);   // void func(int) const;
7
  void func(this A &&self, int x);        // void func(int) &&;
8
  void func(this A const &&self, int x);  // void func(int) const &&;
9
  void gunc(this A self, float y);        // 按值传入对象自身
10

11
  // void gunc(this A &self, float y);    // 会和 gunc(this A, float) 歧义
12
  void hunc(this A &self) {               // void hunc() &;
13
    // this->func(7);                     // 使用 this-deducing 后无法再使用 this
14
    self.func(7);                         // this->func(7) / func(7)
15
  }
16
};
17

18
A a;
19
A const ca;
20
A *pa = &a;
21
A const *pca = &ca;
22

23
void (A::*pf)(int, int) const = &A::f;    // 成员函数指针
24
void (*pfunc)(A const &, int) = &A::func; // 普通函数指针
25

26
a.f(4, 9); (a.*pf)(4, 9); (pa->*pf)(4, 9); std::invoke(pf, a, 4, 9);
27
// pf(a, 4, 9); pf(pa, 4, 9);             // pf 是成员函数指针，需 std::invoke 调用
28
ca.func(7); pfunc(ca, 7); std::invoke(pfunc, ca, 7);
29
// (ca.*pfunc)(7); (pca->*pfunc)(7);      // pfunc 是普通函数指针
30

31
struct B {
32
  template <class T>
33
  void f(this T& self)                    // & / const &
34
  template <class T>
35
  void func(this T&& self);               // & / const & / && / const &&
36
  void gunc(this auto&& self);            // 同上，转发引用
37
};

self 是实打实的派生对象而不是基类指针，这意味着我们不再需要把指针类型转换到实际派生类型了．

1
class Weapon {
2
protected:
3
  float power;
4

5
public:
6
  void attack(this auto&& self) {
7
    if (self.can_level_up()) {
8
      self.fix_impl();
9
      self.power += self.value;
10
    }
11
    self.attack_impl();
12
  }
13

14
  void fix(this auto&& self) {
15
    self.fix_impl();
16
  }
17
};
18

19
class Bow : public Weapon {
20
  friend class Weapon;
21
protected:
22
  int value;
23
public:
24
  bool can_level_up() { /* ... */ }
25
  void fix_impl() { /* ... */ }
26
  void attack_impl() { /* ... */ }
27
};
28

29
class Gun : public Weapon {
30
  friend class Weapon;
31
protected:
32
  int value;
33
public:
34
  bool can_level_up() { /* ... */ }
35
  void fix_impl() { /* ... */ }
36
  void attack_impl() { /* ... */ }
37
};
38

39

40
template <class T>
41
  requires std::is_base_of_v<Weapon, T>
42
void fix_weapon(T &wp) { wp.fix(); }
43

44
int main() {
45
  Bow a;
46
  fix_weapon(a);
47

48

49
  std::unique_ptr<Weapon> b = std::make_unique<Gun>();
50
  // fix_weapon(*b);
51
  std::vector<std::unique_ptr<Weapon>> v;
52
}

实现「注入实现」#

CRTP 的另一个作用就是复用代码的通用逻辑，实现自动化定义成员函数．

案例 1
现有基类 Planet 以及派生类 Sun，Earth，对这两个派生类使用 单例模式．

1
struct Planet {
2
  float mass, radius, heat;
3
  float get_volume() const {
4
    return 3.14f * 4 / 3 * radius * radius * radius;
5
  }
6
};
7

8
class Sun : public Planet {
9
private:
10
  Sun() { /* ... */ };
11
  ~Sun() { /* ... */ };
12
  Sun(Sun const &) = delete;
13
  Sun& operator=(Sun const &) = delete;
14

15
public:
16
  static Sun& get_instance() {
17
    static Sun instance = Sun();
18
    return instance;
19
  }
20

21
  void light(Planet& p) {
22
    float dH = heat / get_volume();
23
    p.heat += dH;
24
    heat -= dH;
25
  }
26
};
27

28
class Earth : public Planet {
29
private:
30
  Earth() { /* ... */ };
31
  ~Earth() { /* ... */ };
32
  Earth(Earth const &) = delete;
33
  Earth& operator=(Earth const &) = delete;
34

35
public:
36
  static Earth& get_instance() {
37
    static Earth instance = Earth();
38
    return instance;
39
  }
40
};

我们发现这种 单例模式 的逻辑高度通用．

失败的实践

尝试使用协议类的形式提取这种逻辑：

1
class Singleton {
2
protected:
3
  Singleton() = default;
4
  ~Singleton() = default;
5
  Singleton(Singleton const &) = delete;
6
  Singleton& operator=(Singleton const &) = delete;
7

8
public:
9
  static Singleton& get_instance() {
10
    static Singleton instance = Singleton();
11
    return instance;
12
  }
13
};
14

15
class Sun : public Singleton, public Planet {
16
protected:
17
  Sun() { /* ... */ }
18
  ~Sun() { /* ... */ }
19
public:
20
  void light(Planet& p) {
21
    float dH = heat / get_volume();
22
    p.heat += dH;
23
    heat -= dH;
24
  }
25
};
26

27
class Earth : public Singleton, public Planet {
28
protected:
29
  Earth() { /* ... */ }
30
  ~Earth() { /* ... */ }
31
};
32

33
int main() {
34
  // 1
35
  Sun& s = Sun::get_instance();
36
  Sun&& t = std::move(Sun::get_instance());
37

38
  // Sun my_sun, another_sun;
39
}

最大的问题就是协议类的单例模式根本没有应用在派生类上：Sun::get_instance() 得到的是 Singleton 的单一实例而非 Sun 的单一实例．我们提取逻辑的同时，类型信息也被抹去了．

我们只是想复用「禁止拷贝，通过 get_instance() 获取唯一实例」这种模式，并在类 Singleton 统一实现这种模式，但又缺乏应用该模式的类型信息．如果实现内容仅类型不同，这个时候就能使用 CRTP 实现「自动化实现」：

1
template <class T>
2
class Singleton {
3
protected:
4
  Singleton() = default;
5
  ~Singleton() = default;
6

7
  Singleton(Singleton const &) = delete;
8
  Singleton& operator=(Singleton const &) = delete;
9
public:
10
  static T& get_instance() {
11
    static T instance = T();
12
    return instance;
13
  }
14
};
15

16
class Sun : public Singleton<Sun>, public Planet {
17

18
  friend class Singleton<Sun>;
19
protected:
20
  Sun() { /* ... */ }
21
  ~Sun() { /* ... */ }
22
public:
23
  void light(Planet& p) {
24
    float dH = heat / get_volume();
25
    p.heat += dH;
26
    heat -= dH;
27
  }
28
};
29

30
class Earth : public Singleton<Earth>, public Planet {
31
  friend class Singleton<Earth>;
32
protected:
33
  Earth() { /* ... */ }
34
  ~Earth() { /* ... */ }
35
};

另一种视角？
也许可以这样理解：CRTP 允许构建一个特别的「函数」，输入是类型、值、「函数」，输出是实现，并把输出注入到派生类里．

案例 2
现有 4 个类 Ball、Cube、Cat、Dog，其中 Ball、Cube 的基类是 Object，Cat、Dog 的基类是 Animal．实现：

Object 的深拷贝方法；

Animal 的深拷贝方法．

我们的拷贝操作发生在上层模块，不知道待拷贝对象的具体类型，如果直接调用上层拷贝构造函数，会发生 对象切片 (object-slicing)，丢失类型信息．

假设现在有

1
Ball x; Cube y; Cat z; Dog w;

浅拷贝返回值实际上指向的还是原来的对象，没有真正拷贝：

1
struct Object {
2
  float object_data;
3
  std::unique_ptr<Object> clone() {
4
    return std::unique_ptr<Object>(this);
5
  }
6
};
7

8
struct Animal {
9
  float animal_data;
10
  std::unique_ptr<Animal> clone() {
11
    return std::unique_ptr<Animal>(this);
12
  }
13
};
14

15
struct Ball : Object { float ball_data; };
16
struct Cube : Object { float cube_data; };
17
struct Cat : Animal { float cat_data; };
18
struct Dog : Animal { float dog_data; };

而深拷贝的 new 操作又必须要求得知具体类型：

1
std::unique_ptr<Object> ret;
2
ret = std::make_unique<Ball>(x);
3
ret = std::make_unique<Cube>(y);
4
ret = std::make_unique<Cat>(z);
5
ret = std::make_unique<Dog>(w);

虽然深拷贝成功，但显式写出了对象的具体类型，违反了开闭原则．

如果愿意，可以保留虚函数接口，把实现下放：

1
struct Object {
2
  float object_data;
3
  virtual ~Object() = default;
4
  virtual std::unique_ptr<Object> clone() = 0;
5
};
6

7
struct Animal {
8
  float animal_data;
9
  virtual ~Animal() = default;
10
  virtual std::unique_ptr<Animal> clone() = 0;
11
};
12

13
struct Ball : Object {
14
  float ball_data;
15
  std::unique_ptr<Object> clone() override {
16
    return std::make_unique<Ball>(*this);
17
  }
18
};
19

20
struct Cube : Object {
21
  float cube_data;
22
  std::unique_ptr<Object> clone() override {
23
    return std::make_unique<Cube>(*this);
24
  }
25
};
26

27
struct Cat : Animal {
28
  float cat_data;
29
  std::unique_ptr<Animal> clone() override {
30
    return std::make_unique<Cat>(*this);
31
  }
32
};
33

34
struct Dog : Animal {
35
  float dog_data;
36
  std::unique_ptr<Animal> clone() override {
37
    return std::make_unique<Dog>(*this);
38
  }
39
};

超级复读机！我们可以使用 CRTP 提取这种通用的逻辑，直接在基类实现它们！

错误的实践

1
template <class Derived>
2
struct Object {
3
  float object_data;
4
  std::unique_ptr<Object> clone() {
5
    auto that = static_cast<Derived *>(this);
6
    return std::make_unique<Derived>(*that);
7
  }
8
};
9

10
template <class Derived>
11
struct Animal {
12
  float animal_data;
13
  std::unique_ptr<Animal> clone() {
14
    auto that = static_cast<Derived *>(this);
15
    return std::make_unique<Derived>(*that);
16
  }
17
};
18

19
struct Ball : Object<Ball> { float ball_data; };
20
struct Cube : Object<Cube> { float cube_data; };
21
struct Cat : Animal<Cat> { float cat_data; };
22
struct Dog : Animal<Dog> { float dog_data; };

CRTP 的副作用就是让基类变成了模板，导致派生类的基类各不相同，失去了动态派发的能力：

1
Ball x; Cube y;
2
std::shared_ptr<Object<Ball>> nx = x.clone(); // are you kidding me?
3
std::shared_ptr<Object<Cube>> ny = y.clone(); // 这还不是违反了开闭原则？

要让基类 Base 免受 CRTP 的副作用，保留基类指针指向派生类对象的能力，我们可以试试套一层辅助类 BaseImpl：

还不完全正确的实践

1
struct Object { float object_data; };
2

3
template <class Derived>
4
struct ObjectImpl : Object {
5
  std::unique_ptr<Object> clone() {
6
    auto that = static_cast<Derived *>(this);
7
    return std::make_unique<Derived>(*that);
8
  }
9
};
10

11
struct Animal { float animal_data; };
12

13
template <class Derived>
14
struct AnimalImpl : Animal {
15
  std::unique_ptr<Animal> clone() {
16
    auto that = static_cast<Derived *>(this);
17
    return std::make_unique<Derived>(*that);
18
  }
19
};
20

21
struct Ball : ObjectImpl<Ball> { float ball_data; };
22
struct Cube : ObjectImpl<Cube> { float cube_data; };
23
struct Cat : AnimalImpl<Cat> { float cat_data; };
24
struct Dog : AnimalImpl<Dog> { float dog_data; };

你会发现的确能够用基类指针指向派生类对象，但本质上你还是失去了多态的 clone：

1
Ball x;
2

3
std::unique_ptr<Object> nx = x.clone();
4

5
std::unique_ptr<Object> nnx = nx->clone();

因此若想保留动态多态，基类 Base 的虚函数接口无论如何也不能丢，然后在 BaseImpl 辅助类里利用 CRTP 实现虚函数！

1
struct Object {
2
  float object_data;
3
  virtual ~Object() = default;
4
  virtual std::unique_ptr<Object> clone() = 0;
5
};
6

7
template <class Derived>
8
struct ObjectImpl : Object {
9
  std::unique_ptr<Object> clone() override {
10
    auto that = static_cast<Derived *>(this);
11
    return std::make_unique<Derived>(*that);
12
  }
13
};
14

15
struct Animal {
16
  float animal_data;
17
  virtual ~Animal() = default;
18
  virtual std::unique_ptr<Animal> clone() = 0;
19
};
20

21
template <class Derived>
22
struct AnimalImpl : Animal {
23
  std::unique_ptr<Animal> clone() override {
24
    auto that = static_cast<Derived *>(this);
25
    return std::make_unique<Derived>(*that);
26
  }
27
};
28

29
struct Ball : ObjectImpl<Ball> { float ball_data; };
30
struct Cube : ObjectImpl<Cube> { float cube_data; };
31
struct Cat : AnimalImpl<Cat> { float cat_data; };
32
struct Dog : AnimalImpl<Dog> { float dog_data; };

NOTE
举个例子，AnimalImpl<Cat> 往 Cat 里注入了 std::unique_ptr<Animal> clone()，Derived 对应 Cat，减少了复读机的感觉．这个时候 CRTP 显然不是为了消除虚表开销，CRTP 并非与 virtual 水火不容．

感觉还是有点复读机，还能再提取吗？只要想保留动态多态，通过 CRTP 注入 clone 实现的方式并不能 override 基类的 clone，override 就是无法避免的，就算再写一个 Copyable<Base, Derived>::copy_impl 注入，也意义不大了．

编译期 for 循环#

基本类型 包括可带 cv 限定的 void、可带 cv 限定的 std::nullptr_t、整型 ¹³、浮点型，与 复合类型 std::is_compound_v<T> 相对． ↩
nullptr 是 std::nullptr_t 的实例．
std::nullptr_t 并不是指针类型，即 std::is_pointer_v<std::nullptr_t> -> false；
std::nullptr_t 可 (显式/隐式) 转换成指针类型，如 void *，char const *；
std::nullptr_t 不能在模板中做类型推导 std::nullptr_t -> T*． ↩
算术类型 包括整型、浮点类型、这些类型的 cv 限定版本． ↩
整型包括布尔类型、字符类型、整数类型． ↩
只能检测普通指针、函数指针、成员指针，不能检测智能指针，需自定义 trait，如：template <class T> struct is_smart<std::shared_ptr<T>> : std::true_type {}; ↩
空类型不含非静态成员变量、虚函数、虚基类，如 struct { static int x; int f(){} }． ↩
平凡类型 包括标量类型 ²⁶、平凡类、这些类型的数组、cv 限定版本．
称一个类 可平凡复制，当且仅当其 (复制/移动)(构造函数/赋值运算符)、析构函数都是默认的，且无虚函数、虚基类．
可平凡复制类型的内存分布是连续的，因此可以通过 std::memcpy 按字节将对象序列化成 unsigned char [] 或 std::byte []．虽然内存连续，但内存布局和 C 语言不同，成员顺序由编译器决定 (比如访问权限相同的成员变量可能重新放在一起，C 语言不认识这些访问说明符)，因此不能兼容 C 程序．\ ↩
一个类在可平凡复制的基础上，具有平凡的默认构造函数，这时称它为 平凡类． ↩
标准布局类型 包括标量类型 ²⁶、标准布局类、这些类型的数组、cv 限定版本．
一个类如果无虚函数、虚基类，所有非静态数据成员都具有相同的访问说明符，在继承体系中最多只有一个类中有非静态数据成员，在继承体系中所有类的第一个非静态成员的类型与其基类不同 (在 C++ 中，空基类的地址与第一个非静态成员共享．一旦相同，由于标准规定相同类型的对象地址必须不同，势必多分配出空间以存储基类地址，内存布局发生变化)，这时类的内存布局 (成员在内存中的排列方式) 与 C 语言的结构体完全一致，也称标准布局，这个类也被称为 标准布局类．标准布局类允许用户自定义成员函数．
如果平凡类型使用标准内存布局，则称这个类型为 POD 类型，与 C 语言的类型无缝衔接，相应的 trait 为 std::is_pod_v<T>，该 trait 在 C++20 中弃用，取而代之的是 std::is_trivial_v<T> && std::is_standard_layout_v<T>． ↩
聚合类型 可以是数组，也可以是一个类：这个类没有自定义构造函数，所有非静态成员都是 public 的，无虚函数、虚基类，继承只能是公有继承．在 C++17 之前，这个类不能有基类．聚合类型的特色便是可以聚合初始化、在结构化绑定中可分解． ↩
返回 true，当且仅当 std::swap(std::declval<T>(), std::declval<U>()) 在不求值语境中是良构的． ↩
等价于 std::is_swappable_with_v<T&, T&>，只要 T 是可引用的类型 (其实就是非 void)，就返回 true． ↩
返回 true，当且仅当 T obj(std::declval<Args>()...); 在不求值语境中是良构的． ↩ ↩²
返回 true，当且仅当 std::declval<T>() = std::declval<U>() 在不求值语境中是良构的． ↩
T 是引用类型，或者 std::declval<U&>().~U() 在不求值语境中是良构的，其中 U 是 T 移除所有多维数组维度后的类型，即 using U = std::remove_all_extents_t<T>;，返回 true；对于可带 cv 限定的 void、函数类型、未知边界的数组，返回 false． ↩
只要是能被 std::invoke 调用的类型都被称为 invocable，如函数、函数指针、成员函数指针、仿函数、lambda 表达式 (匿名仿函数)、std::function 对象、std::bind 对象．std::is_invocable_v<T> 仅检查语法上能否调用，可触发隐式转换． ↩
cv 限定符也要完全相同． ↩
隐式转换 主要发生在算术类型的标准转换、cv 限定的添加、从派生类到基类的指针/引用转换、从基类到派生类的成员 (变量/函数) 指针转换、从数组/函数到指针的类型退化、用户定义的非 explicit 单参构造函数、用户定义的 explicit 转换函数、函数实参到形参的转换、函数返回值到返回类型的转换． ↩
若 From 和 To 都是可能带 cv 限定的 void，则返回 true． ↩
D 必须是标准内存布局 ⁹，才能保证从 D * 转来的 B * 仍能正常工作，否则 D 的首地址将存放非空基类 B 的信息．此外如果 D 和 B 相同，返回 true． ↩
s.*mp (即 s.m) 与 s 首地址重合，相当于 S 必须是标准内存布局 ⁸，否则首地址将存放非空基类信息．此时 reinterpret_cast<M&>(s) 能唯一指代 s.m．此外要返回 true，M 得是对象类型，mp 是非空指针． ↩
若相应维度的元素数量未知，则返回 0． ↩
若 sizeof...(B) 为 0，则 std::conjunction<B...> 继承 std::true_type，否则继承第一个 bool(B::value) 为 false 的 B，若 bool(B::value) && ... 为 true，继承最后一个 B．B 通常是 std::true_type / std::false_type． ↩
若 sizeof...(B) 为 0，则 std::disjunction<B...> 继承 std::false_type，否则继承第一个 bool(B::value) 为 true 的 B，若 bool(B::value) || ... 为 false，继承最后一个 B．B 通常是 std::true_type / std::false_type． ↩
继承 std::bool_constant<!bool(B::value)>． ↩
标量类型 包括算术类型 ³、枚举类型、指针类型、成员指针类型、std::nullptr_t、这些类型的 cv 限定版本，对应的 trait 为 std::is_scalar_v<T>． ↩ ↩²

模板也是「函数」#

type_traits#

类型判断#

类别#

属性#

可支持的操作#

类型关系#

类型查询#

类型处理#

Trait 运算#

约束类型#

利用 SFINAE 约束类型#

利用 Concept 约束类型#

CRTP#

实现「静态多态」/「接口约定」#

实现「注入实现」#

编译期 for 循环#

Footnotes#