# C++设计模式：CRTP 模式——编译期多态的奇妙递归

 

在 C++ 多态编程中，我们习惯了使用虚函数和继承来实现运行时多态：

```cpp
class Shape {
public:
    virtual double area() const = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape {
public:
    double area() const override { return 3.14 * radius_ * radius_; }
private:
    double radius_;
};

// 使用时需要通过基类指针/引用调用
Shape* shape = newCircle();
shape->area();  // 虚函数调用，有运行时开销
```

**问题 1：虚函数调用开销**

每次虚函数调用都需要通过虚表（vtable）间接跳转，这会带来以下问题：

-  无法内联优化
-  破坏 CPU 流水线
-  缓存不友好
-  在性能敏感场景下开销不可忽视

**问题 2：类型信息丢失**

运行时多态会丢失具体类型信息：

```cpp
void processShapes(std::vector<Shape*> shapes) {
    for (auto* shape : shapes) {
        // 无法直接访问 Circle 的特有方法
        // shape->getRadius();  // ❌ 编译错误
    }
}
```

**问题 3：不支持非类型参数**

虚函数机制只能用于成员函数，无法用于：

-  静态函数多态
-  类型作为模板参数的编译期计算
-  编译期类型特化

### 生活类比

想象一下这样的场景：

**传统方式（运行时多态）**：
你打电话给客服中心，根据提示"按1选择中文服务、按2选择英文服务"，然后系统根据你的按键**运行时**路由到不同的客服人员。这需要额外的时间来建立连接，而且你不知道具体是哪位客服。

**CRTP 方式（编译期多态）**：
你直接知道"中文服务请找张三，英文服务请找李四"，然后**直接**拨打对应人员的分机号。没有中间路由环节，沟通效率更高，而且你清楚知道在和谁对话。

### 对比图

```
传统虚函数多态：
基类指针 --[vtable查找]--> 派生类实现 --[间接调用]--> 具体函数
     ↓                          ↓                      ↓
  运行时查找               动态绑定              无法内联

CRTP 编译期多态：
   派生类 --[模板实例化]--> 基类<派生类> --[直接调用]--> 派生类函数
      ↓                           ↓                      ↓
   编译期确定                   静态绑定              可以内联
```

**CRTP 模式就是为解决这个问题而生的。** 它利用模板的编译期实例化特性，在编译期确定类型，实现零开销的多态调用。

------

## 模式详解

### 模式定义

> **CRTP 模式（Curiously Recurring Template Pattern，奇异递归模板模式）**，核心思想是：**让派生类将自己作为模板参数传递给基类，从而在基类中获取派生类的类型信息，实现编译期多态。**

名称的"奇异"来源于这种写法初看很奇怪——派生类继承自"以自己为模板参数的基类"：

```cpp
template <typename Derived>
class Base {
public:
    void interface() {
        // 在基类中调用派生类的实现
        static_cast<Derived*>(this)->implementation();
    }
};

class Derived : public Base<Derived> {  // ← 这里看起来很"奇异"
public:
    void implementation() {
        // 派生类的具体实现
    }
};
```

### 核心原理

CRTP 的核心思想是通过**模板实例化**和**静态类型转换**，在编译期将基类中的调用静态绑定到派生类的实现：

```
编译过程：

1. 模板实例化
   class Derived : public Base<Derived>
                    ↓
   编译器生成 Base<Derived> 的完整代码

2. 类型确定
   Base<Derived> 中，Derived 是完整类型
   static_cast<Derived*>(this) 可以安全转换

3. 静态绑定
   static_cast<Derived*>(this)->implementation()
   直接编译为调用 Derived::implementation()
   无虚表查找，可以内联
```

### 基本实现（经典版本）

让我们实现一个经典的几何形状计算示例，展示 CRTP 如何替代虚函数：

```cpp
#include <iostream>
#include <chrono>
#include <memory>
#include <utility>

// ========== 传统虚函数方式 ==========
class Shape {
public:
    virtual double area() const = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape {
public:
    explicit Circle(double r) : radius_(r) {}
    double area() const override {
        return 3.14159265358979323846 * radius_ * radius_;
    }
private:
    double radius_;
};

class Rectangle : public Shape {
public:
    Rectangle(double w, double h) : width_(w), height_(h) {}
    double area() const override { return width_ * height_; }
private:
    double width_;
    double height_;
};

// ========== CRTP 方式 ==========
template <typename Derived>
class ShapeCRTP {
public:
    double area() const {
        // 编译期将调用静态绑定到具体派生类
        return static_cast<const Derived*>(this)->areaImpl();
    }
};

class CircleCRTP : public ShapeCRTP<CircleCRTP> {
public:
    explicit CircleCRTP(double r) : radius_(r) {}
    double areaImpl() const {
        return 3.14159265358979323846 * radius_ * radius_;
    }
private:
    double radius_;
};

class RectangleCRTP : public ShapeCRTP<RectangleCRTP> {
public:
    RectangleCRTP(double w, double h) : width_(w), height_(h) {}
    double areaImpl() const { return width_ * height_; }
private:
    double width_;
    double height_;
};
```

**经典版本存在的问题**：

1. **类型安全性依赖程序员**：`static_cast` 的正确性完全依赖程序员确保模板参数确实是派生类类型
2. **不能在容器中统一存储**：不像 `Shape*` 可以存储多种形状，CRTP 的每个派生类都是不同类型
3. **接口需要显式定义**：编译器不会强制要求派生类实现 `areaImpl()`，缺少编译期检查

------

## 关键技术专题

### 1. static_cast 安全性分析

CRTP 中 `static_cast<Derived*>(this)` 的安全性保障：

```cpp
template <typename Derived>
class Base {
public:
    void interface() {
        // 为什么这个 static_cast 是安全的？
        static_cast<Derived*>(this)->implementation();
    }
};

class Derived : public Base<Derived> {  // 保证：this 实际指向 Derived
public:
    void implementation() { /* ... */ }
};
```

**安全性保证机制**：

1. **类型同一性**：当 `Derived` 继承 `Base<Derived>` 时，`Base<Derived>` 中的 `this` 指针在运行时**必然**指向 `Derived` 对象
2. **编译期检查**：如果错误地使用 `Base<OtherType>`，会在模板实例化时暴露类型不匹配
3. **内存布局**：`Derived` 对象的内存布局以 `Base<Derived>` 子对象开始，指针转换不改变地址

### 2. 编译期多态 vs 运行时多态

```cpp
// 运行时多态（动态绑定）
void processVirtual(Shape* shape) {
    shape->area();  // 调用哪个函数？运行时决定
}

// 编译期多态（静态绑定）
template <typename T>
void processCRTP(ShapeCRTP<T>* shape) {
    shape->area();  // 调用哪个函数？编译时决定
}
```

### 3. 标准库中的 CRTP 应用

#### std::enable_shared_from_this

```cpp
#include <memory>
class Widget : public std::enable_shared_from_this<Widget> {
public:
    std::shared_ptr<Widget> getShared() {
        // 正确：返回管理 this 的 shared_ptr
        return shared_from_this();
    }
    
    void dangerous() {
        // 错误！不要这样做
        // return std::shared_ptr<Widget>(this);
        // 这会导致 this 被两个 shared_ptr 管理而双重释放
    }
};

// 使用示例
auto widget = std::make_shared<Widget>();
auto widget2 = widget->getShared();  // 正确共享所有权
```

`enable_shared_from_this` 的实现原理（简化版）：

```cpp
namespace std {
template <typename T>
class enable_shared_from_this {
public:
    shared_ptr<T> shared_from_this() {
        return shared_ptr<T>(weak_this_.lock());
    }
    
protected:
    enable_shared_from_this() = default;
    ~enable_shared_from_this() = default;
    
private:
    template <typename U> friendclass shared_ptr;
    weak_ptr<T> weak_this_;  // shared_ptr 构造时会设置这个成员
};
}
```

------

## 现代 C++ 实现

### 1. 概念约束（C++20）

使用 C++20 Concepts 可以让错误信息更清晰。不过 CRTP 有一个细节：派生类继承 `Base<Derived>` 时，`Derived` 还不是完整类型，所以不要把约束直接写在类模板声明上。更稳妥的做法是把检查延迟到成员函数实例化时：

```cpp
#include <iostream>
#include <concepts>
#include <type_traits>

// 定义概念：类型必须有 areaImpl 方法
template <typename T>
concept HasArea = requires(const T& t) {
    { t.areaImpl() } -> std::convertible_to<double>;
};

// CRTP 基类：把约束放到成员函数上，避开不完整类型问题
template <typename Derived>
class ShapeModern {
public:
    double area() const requires HasArea<Derived> {
        return static_cast<const Derived*>(this)->areaImpl();
    }
};

class CircleModern : public ShapeModern<CircleModern> {
public:
    explicit CircleModern(double r) : radius_(r) {}
    double areaImpl() const {
        return 3.14159265358979323846 * radius_ * radius_;
    }
private:
    double radius_;
};

class BadShape : public ShapeModern<BadShape> {
    // 没有 areaImpl
};
```

### 2. constexpr 和编译期计算

CRTP 支持编译期常量表达式计算：

```cpp
template <typename Derived>
class CompileTimeShape {
public:
    constexpr double area() const {
        return static_cast<const Derived*>(this)->areaImpl();
    }
    
    constexpr double perimeter() const {
        return static_cast<const Derived*>(this)->perimeterImpl();
    }
};

class constexprSquare : public CompileTimeShape<constexprSquare> {
public:
    constexpr constexprSquare(double side) : side_(side) {}
    
    constexpr double areaImpl() const { return side_ * side_; }
    constexpr double perimeterImpl() const { return 4 * side_; }
    
private:
    double side_;
};
```

### 3. 混合模式：CRTP + 虚函数

结合两者的优势：

```cpp
template <typename Derived>
class BaseWithVirtual {
public:
    // CRTP 提供的性能优化路径
    void fastPath() {
        static_cast<Derived*>(this)->fastPathImpl();
    }
    
    // 虚函数提供的灵活性
    virtual void slowPath() {
        static_cast<Derived*>(this)->slowPathImpl();
    }
    
    virtual ~BaseWithVirtual() = default;
};

class Hybrid : public BaseWithVirtual<Hybrid> {
public:
    void fastPathImpl() {
        // 编译期确定，可内联
        std::cout << "Fast path (CRTP)\n";
    }
    
    void slowPathImpl() override {
        // 虚函数调用，可多态
        std::cout << "Slow path (Virtual)\n";
    }
};
```

------

### 决策流程图

```
需要多态？
  ├─ 否 → 使用普通函数/类
  │
  └─ 是 → 类型在编译期确定？
            ├─ 是 → 性能敏感？
            │        ├─ 是 → 使用 CRTP
            │        └─ 否 → 考虑普通模板
            │
            └─ 否 → 需要跨 DLL 边界？
                     ├─ 是 → 使用虚函数
                     └─ 否 → 考虑 std::variant
```

------

## 写在最后

CRTP 模式展示了 C++ 模板系统的强大威力——通过巧妙的递归模板设计，在编译期实现零开销的多态。它是现代 C++ 库（如 Eigen、Boost）中高性能抽象的核心技术。

虽然 CRTP 的语法初看有些怪异，但一旦理解其本质——**利用模板实例化在编译期确定类型**——就会发现它是一个强大而优雅的工具。

**实现演进路线**：

```
传统虚函数 → CRTP 基础应用 → 概念约束 → 混合模式
    ↓            ↓              ↓          ↓
  运行时开销   编译期多态     类型安全    灵活性
  间接调用    零开销抽象    编译期检查   双重优势
```

**记住这 3 句话**：

> **CRTP 将多态从运行时移到编译期，以模板的复杂性换取运行时的零开销。**
> **理解 CRTP 的关键是认识到模板实例化时，派生类已经是完整类型。**
> **CRTP 不是银弹，适合编译期类型确定的场景，运行时多态仍需虚函数。**

<!-- markdown for nginx, see https://phus.lu -->
<script>
!function(){
	var dom = {
		element: null,
		get: function (o) {
			var obj = Object.create(this)
			obj.element = (typeof o == "object") ? o : document.createElement(o)
			return obj
		},
		add: function (o) {
			var obj = dom.get(o)
			this.element.appendChild(obj.element)
			return obj
		},
		text: function (t) {
			this.element.appendChild(document.createTextNode(t))
			return this
		},
		attr: function (k, v) {
			this.element.setAttribute(k, v)
			return this
		}
	}

	if (!document.head) return
	head = dom.get(document.head)
	head.add('meta').attr('charset', 'utf-8')
	head.add('meta').attr('name', 'viewport').attr('content', 'width=device-width,initial-scale=1')

	if (!document.body) {
		document.write(["<div class=\"container\">",
		"<h3>nginx.conf</h3>",
		"<textarea rows=6 cols=50>",
		"# download markdown.html to /wwwroot",
		"location ~ \\.md$ {",
		"    default_type text/html;",
		"    add_after_body /markdown.html;",
		"}",
		"</textarea>",
		"</div>"].join("\n"))
		return
	}

	var bodytext = document.body.innerHTML
	document.body.innerHTML = ''

	div = dom.get('div').attr('class', 'container')

	div.add('script').attr('src', 'https://cdnjs.cloudflare.com/ajax/libs/marked/0.5.2/marked.min.js').attr('integrity', 'sha256-zFUosuESzULu5P+SZdjRRtBZR8+1u5RZDlbt3Q5KL8U=').attr('crossorigin', 'anonymous')
	div.add('link').attr('rel', 'stylesheet').attr('href', 'https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/5.1.0/github-markdown-light.min.css').attr('integrity', 'sha256-WQx0Y6LLZeGv3V3NVVge+YIL5MIOt45RPuFdkyNodls=').attr('crossorigin', 'anonymous')

	title = decodeURIComponent(document.location.pathname.replace(/.*\//, '').replace(/\.html$/, ''))
	document.title = '《' + title.replace(/\.md$/, '') + '》'
	tbody = div.add('table').add('tbody')
	tbody.add('tr').add('th').text(title).attr('class', 'octicon-book')
	tbody.add('tr').add('td').add('div').attr('id', 'readme').attr('class', 'markdown-body')

	wait = function (name, callback) {
		var interval = 10; // ms
		window.setTimeout(function() {
			if (window[name]) {
				callback(window[name])
			} else {
				window.setTimeout(arguments.callee, interval)
			}
		}, interval)
	}
	wait('marked', function() {
		document.getElementById("readme").innerHTML = marked.parse(bodytext)
	})

	document.body.appendChild(div.element)
}()
</script>

<style>
body {
	margin: 0;
	font-family: "ubuntu", "Tahoma", "Microsoft YaHei", Arial, Serif;
}
.markdown-body {
	float: left;
	font-family: "ubuntu", "Tahoma", "Microsoft YaHei", Arial, Serif;
}
.container {
	padding-right: 15px;
	padding-left: 15px;
	margin-right: auto;
	margin-left: auto;
}
@media (min-width: 768px) {
	.container {
		max-width: 80%;
	}
}
@media (min-width: 992px) {
	.container {
		max-width: 70%;
	}
}
@media (min-width: 1200px) {
	.container {
		max-width: 60%;
	}
}
table {
	width: 100%;
	max-width: 100%;
	margin-bottom: 20px;
	border: 1px solid #ddd;
	padding: 0;
	border-collapse: collapse;
}
table th {
	font-size: 14px;
}
table tr {
	border: 1px solid #ddd;
	padding: 5px;
}
table th, table td {
	border: 1px solid #ddd;
	font-size: 14px;
	line-height: 20px;
	padding: 3px;
	text-align: left;
}
.octicon-book {
	background-position: center left;
	background-repeat: no-repeat;
	padding-left: 20px;
	background-image: url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' viewBox='0 0 16 16'%3E%3Cpath d='M3,5 L7,5 L7,6 L3,6 L3,5 L3,5 Z M3,8 L7,8 L7,7 L3,7 L3,8 L3,8 Z M3,10 L7,10 L7,9 L3,9 L3,10 L3,10 Z M14,5 L10,5 L10,6 L14,6 L14,5 L14,5 Z M14,7 L10,7 L10,8 L14,8 L14,7 L14,7 Z M14,9 L10,9 L10,10 L14,10 L14,9 L14,9 Z M16,3 L16,12 C16,12.55 15.55,13 15,13 L9.5,13 L8.5,14 L7.5,13 L2,13 C1.45,13 1,12.55 1,12 L1,3 C1,2.45 1.45,2 2,2 L7.5,2 L8.5,3 L9.5,2 L15,2 C15.55,2 16,2.45 16,3 L16,3 Z M8,3.5 L7.5,3 L2,3 L2,12 L8,12 L8,3.5 L8,3.5 Z M15,3 L9.5,3 L9,3.5 L9,12 L15,12 L15,3 L15,3 Z' /%3E%3C/svg%3E");
}
</style>