高级模板技巧——CRTP、Variadic Templates 与 Fold Expressions on Dorkytiger 的小屋

CRTP（奇异递归模板模式）

Mon, 01 Jan 0001 00:00:00 +0000

一、解决什么问题？

问题：你有一个通用的算法骨架（比如"遍历 + 处理 + 汇总"），但其中的"处理"步骤在不同类型中不同。有两种选择：

虚函数：方便，但每次调用都要查 vtable，而且虚函数不能内联。
CRTP：消除虚函数开销，但要求类型在编译期已知。

CRTP 的典型场景：

你的类继承一个基类，但基类需要调用派生类的成员函数。
你对性能有要求，不能接受虚函数调用的 vtable 寻址 + 无法内联。
你知道派生类的具体类型（编译期已知）。

二、底层原理：编译期 `this` 转换

template <typename Derived>
class Base {
public:
    void interface() {
        // static_cast 在编译期完成，不产生运行时开销
        // 等价于直接调用 Derived::impl()
        static_cast<Derived*>(this)->impl();
    }
};

class MyClass : public Base<MyClass> {
public:
    void impl() { /* ... */ }
};

编译器眼中的展开：

MyClass 继承自 Base<MyClass>。

当调用 my_obj.interface() 时：
  编译器看到 Base<MyClass>::interface()
  → static_cast<MyClass*>(this) → 编译器知道 this 的实际类型是 MyClass*
  → 直接调用 MyClass::impl()
  → 可以内联（inline）！

三、虚函数 vs CRTP——性能差距有多大？

// 写法 A：虚函数
struct ShapeVirt { virtual double area() const = 0; };
struct CircleVirt : ShapeVirt {
    double r_;
    double area() const override { return 3.14 * r_ * r_; }
};

// 写法 B：CRTP
template <typename Derived>
struct ShapeCRTP {
    double area() const { return static_cast<const Derived*>(this)->area_impl(); }
};
struct CircleCRTP : ShapeCRTP<CircleCRTP> {
    double r_;
    double area_impl() const { return 3.14 * r_ * r_; }
};

面试官会问：“CRTP 比虚函数快多少？为什么？”

可变参数模板（Variadic Templates）

Mon, 01 Jan 0001 00:00:00 +0000

一、解决什么问题？

问题：在 C++03 中，你想写一个"接收任意数量参数的函数"，只能靠：

函数重载（写 N 个版本，累死）。
C 风格的 ...（va_args，类型不安全）。

Variadic Templates 的目标：类型安全的任意参数。

二、什么时候用它？

场景	例子
包装/转发函数参数	`std::make_unique<T>(args...)`、`std::thread(func, args...)`
实现类型安全的 printf	`std::format("{} {}", a, b)`
构造 tuple	`std::tuple<int, double, string>(1, 2.0, "hello")`
实现工厂模式	`factory.create<Widget>(arg1, arg2, arg3)`
日志库	`log.info("user {} logged in at {}", name, time)`

三、递归展开：编译器是怎么处理"任意参数"的？

// 你想写一个打印任意数量、任意类型参数的函数：
print(1, 2.0, "hello", 'c');

// Variadic Templates 的做法：递归 + 终止
void print() {}  // ① 终止函数：0 个参数时调用

template <typename T, typename... Args>
void print(T first, Args... rest) {
    std::cout << first << " ";  // 打印第一个
    print(rest...);              // ② 用剩余参数继续递归
}

编译器实例化的过程：

折叠表达式（Fold Expressions）

Mon, 01 Jan 0001 00:00:00 +0000

一、解决什么问题？

问题：在 C++17 之前，你想对可变参数包做一个"累加"操作，必须写递归模板：

// C++11 风格的求和（痛苦）
auto sum() { return 0; }  // 终止
template <typename T, typename... Args>
auto sum(T first, Args... rest) {
    return first + sum(rest...); // 递归
}

折叠表达式：一句话搞定。

二、四种折叠——看明白一张表就够了

语法	名称	对 `(1, 2, 3, 4)` 的展开
`(args + ...)`	一元右折叠	`(1 + (2 + (3 + 4)))`
`(... + args)`	一元左折叠	`(((1 + 2) + 3) + 4)`
`(0 + ... + args)`	二元右折叠	`(0 + (1 + (2 + 3)))`
`(args + ... + 0)`	二元左折叠	`(((1 + 2) + 3) + 0)`

要不要区分左和右？

`std::index_sequence` —— 破解"tuple 展开"问题

Mon, 01 Jan 0001 00:00:00 +0000

一、解决什么问题？

你有一个 tuple，想调用一个函数，参数就是这个 tuple 里的元素：

auto t = std::make_tuple(1, 2.0, "hello");
// 我想调用：func(1, 2.0, "hello")
// 但怎么写？不能写 func(t[0], t[1], t[2]) 因为 tuple 不能用 [] 下标

index_sequence 的答案：编译期生成 0, 1, 2, ..., N-1 这个序列，然后用包展开去 get tuple 的元素。

二、`std::apply` 的底层实现（搞懂这个就懂了 index_sequence）

// 1. 先生成 index_sequence<0, 1, 2>
// 2. 用 (get<I>(t))... 展开成 get<0>(t), get<1>(t), get<2>(t)

template <typename Func, typename Tuple, size_t... I>
auto apply_impl(Func&& f, Tuple&& t, std::index_sequence<I...>) {
    // I... = 0, 1, 2
    // get<I>(t)... = get<0>(t), get<1>(t), get<2>(t)
    return f(std::get<I>(std::forward<Tuple>(t))...);
}

template <typename Func, typename Tuple>
auto my_apply(Func&& f, Tuple&& t) {
    // tuple_size_v<Tuple> 得到元素个数，比如 3
    // make_index_sequence<3> → index_sequence<0, 1, 2>
    return apply_impl(
        std::forward<Func>(f),
        std::forward<Tuple>(t),
        std::make_index_sequence<std::tuple_size_v<std::decay_t<Tuple>>>{}
    );
}

my_apply([](int a, double b, const char* c) {
    std::cout << a << b << c;
}, t);
// 展开为：apply_impl(lambda, t, index_sequence<0, 1, 2>)
// → lambda(get<0>(t), get<1>(t), get<2>(t))
// → lambda(1, 2.0, "hello")

什么时候你会自己写这个？

`std::tuple` 的编译期遍历

Mon, 01 Jan 0001 00:00:00 +0000

一、解决什么问题？

std::tuple 的元素类型不同，不能用普通 for 循环遍历。

需求：我想对 tuple 的每个元素调用同一函数。

std::tuple<int, double, std::string> t = {1, 2.0, "hello"};
// 我想实现：
// print(get<0>(t));
// print(get<1>(t));
// print(get<2>(t));
// 但不能写 for (int i = 0; i < 3; i++) print(get<i>(t)); ← 编译 error，i 不是编译期常量

二、`if constexpr` + 递归——编译期循环

template <typename Tuple, typename Func, size_t I = 0>
void tuple_for_each(const Tuple& t, Func&& f) {
    if constexpr (I < std::tuple_size_v<Tuple>) {
        f(std::get<I>(t));                             // 处理第 I 个元素
        tuple_for_each<Tuple, Func, I + 1>(t,           // 递归处理下一个
                                           std::forward<Func>(f));
    }
    // if constexpr 的关键：当 I >= tuple_size 时，
    // 这个递归调用分支的代码直接被编译器丢弃，
    // 不会产生无限递归！
}

编译器展开：

高级模板技巧——CRTP、Variadic Templates 与 Fold Expressions on Dorkytiger 的小屋

CRTP（奇异递归模板模式）

一、解决什么问题？

二、底层原理：编译期 this 转换

三、虚函数 vs CRTP——性能差距有多大？

可变参数模板（Variadic Templates）

一、解决什么问题？

二、什么时候用它？

三、递归展开：编译器是怎么处理"任意参数"的？

折叠表达式（Fold Expressions）

一、解决什么问题？

二、四种折叠——看明白一张表就够了

`std::index_sequence` —— 破解"tuple 展开"问题

一、解决什么问题？

二、std::apply 的底层实现（搞懂这个就懂了 index_sequence）

`std::tuple` 的编译期遍历

一、解决什么问题？

二、if constexpr + 递归——编译期循环

二、底层原理：编译期 `this` 转换

二、`std::apply` 的底层实现（搞懂这个就懂了 index_sequence）

二、`if constexpr` + 递归——编译期循环