CRTP（Curiously Recurring Template Pattern）

C++ 中的 CRTP（奇異遞歸模板模式）

CRTP（Curiously Recurring Template Pattern）是一種利用模板繼承實現 靜態多態（Static Polymorphism） 的設計模式。通過基類模板以派生類作為模板參數，CRTP 允許在編譯期實現多態行為，避免虛函數開銷，同時提供靈活的類型操作。以下通過代碼和底層原理全面解析其實現和應用。

1. CRTP 的基本結構

1.1 核心思想

基類模板：接受派生類作為模板參數。
派生類：繼承自以自身為模板參數的基類模板。

// 基類模板
template <typename Derived>
class Base {
public:// 通過靜態轉換訪問派生類Derived& derived() { return static_cast<Derived&>(*this); }
};// 派生類繼承自以自身為模板參數的基類
class MyDerived : public Base<MyDerived> {// 派生類的實現
};

2. CRTP 的典型應用場景

2.1 靜態多態（替代虛函數）

template <typename Derived>
class Shape {
public:void draw() {// 調用派生類的具體實現static_cast<Derived*>(this)->drawImpl();}
};class Circle : public Shape<Circle> {
public:void drawImpl() { std::cout << "Drawing Circle" << std::endl; }
};class Square : public Shape<Square> {
public:void drawImpl() { std::cout << "Drawing Square" << std::endl; }
};int main() {Circle circle;Square square;circle.draw();  // 輸出 "Drawing Circle"square.draw();  // 輸出 "Drawing Square"
}

底層原理：

通過 static_cast 在編譯期將基類指針轉換為派生類指針，直接調用具體實現。
無虛函數表（vtable）開銷，性能更高。

2.2 接口擴展與代碼復用

template <typename Derived>
class Addable {
public:Derived operator+(const Derived& other) const {Derived result = static_cast<const Derived&>(*this);result += other;return result;}
};class Vector : public Addable<Vector> {
public:int x, y;Vector(int x, int y) : x(x), y(y) {}Vector& operator+=(const Vector& other) {x += other.x;y += other.y;return *this;}
};int main() {Vector v1(1, 2), v2(3, 4);Vector v3 = v1 + v2;  // 使用基類的 operator+ 實現std::cout << v3.x << ", " << v3.y << std::endl;  // 輸出 "4, 6"
}

2.3 對象計數（編譯期統計）

template <typename Derived>
class ObjectCounter {
public:static int count;ObjectCounter() { count++; }~ObjectCounter() { count--; }
};template <typename Derived>
int ObjectCounter<Derived>::count = 0;class MyClass : public ObjectCounter<MyClass> {};int main() {MyClass a, b;std::cout << MyClass::count << std::endl;  // 輸出 "2"{MyClass c;std::cout << MyClass::count << std::endl;  // 輸出 "3"}std::cout << MyClass::count << std::endl;  // 輸出 "2"
}

3. CRTP 的底層原理

3.1 模板實例化與類型推導

基類模板參數：在派生類定義時，將自身類型傳遞給基類模板。
靜態類型轉換：通過 static_cast 在編譯期完成派生類類型的解析。

3.2 符號生成與名稱修飾

每個派生類實例化基類模板時，生成獨立的符號。
例如：
- Base<Circle> → _4BaseI6CircleE
- Base<Square> → _4BaseI6SquareE

4. CRTP 的優缺點

優點	缺點
無虛函數開銷，性能更高	代碼可讀性較低，設計復雜度較高
編譯期多態，避免運行時類型檢查	派生類需明確知曉基類模板的實現細節
靈活的類型操作（如運算符重載、靜態接口擴展）	模板錯誤信息可能難以調試

5. CRTP 的高級應用

5.1 鏈式調用（Fluent Interface）

template <typename Derived>
class Chainable {
public:Derived& self() { return static_cast<Derived&>(*this); }Derived& setName(const std::string& name) {self().name = name;return self();}Derived& setValue(int value) {self().value = value;return self();}
};class Config : public Chainable<Config> {
public:std::string name;int value;
};int main() {Config config;config.setName("MyApp").setValue(42);std::cout << config.name << " " << config.value << std::endl; // 輸出 "MyApp 42"
}

5.2 編譯期策略模式

template <typename Derived>
class SortingPolicy {
public:void sort(int* data, size_t size) {static_cast<Derived*>(this)->sortImpl(data, size);}
};class QuickSort : public SortingPolicy<QuickSort> {
public:void sortImpl(int* data, size_t size) {std::cout << "QuickSort" << std::endl;// 具體實現}
};class MergeSort : public SortingPolicy<MergeSort> {
public:void sortImpl(int* data, size_t size) {std::cout << "MergeSort" << std::endl;// 具體實現}
};int main() {int arr[5] = {5, 3, 1, 4, 2};QuickSort sorter;sorter.sort(arr, 5);  // 輸出 "QuickSort"
}

6. 總結

場景	技術要點
靜態多態	通過 `static_cast` 調用派生類方法，避免虛函數開銷
接口擴展	基類模板提供通用操作（如 `operator+`），派生類實現具體邏輯（如 `operator+=`）
編譯期對象計數	利用靜態成員變量統計實例數量
鏈式調用	返回派生類引用實現鏈式操作
策略模式	基類定義策略接口，派生類實現具體策略

CRTP 通過模板繼承和編譯期類型轉換，將多態行為提前到編譯期處理，適用于高性能、低延遲場景。合理使用可提升代碼復用性和靈活性，但需注意設計復雜度和可維護性。

多選題

題目 1：CRTP 基類如何訪問派生類的方法？

以下代碼的輸出是什么？

template <typename Derived>
class Base {
public:void execute() {static_cast<Derived*>(this)->impl();}
};class Derived : public Base<Derived> {
public:void impl() { std::cout << "Derived impl" << std::endl; }
};int main() {Derived d;d.execute();return 0;
}

A. 輸出 Derived impl
B. 編譯失敗，Base 無法訪問 Derived 的 impl()
C. 運行時錯誤，類型轉換失敗
D. 輸出未定義行為

題目 2：靜態多態與動態多態的性能對比

以下關于 CRTP 的說法，哪一項正確？

A. CRTP 通過虛函數表實現多態，性能與動態多態相同
B. CRTP 在編譯期解析方法調用，性能優于動態多態
C. CRTP 必須在運行時通過 RTTI 檢查類型
D. CRTP 的性能不如動態多態，因為模板實例化開銷大

題目 3：CRTP 實現對象計數的行為

以下代碼的輸出是什么？

template <typename Derived>
class Counter {
public:static int count;Counter() { count++; }~Counter() { count--; }
};template <typename Derived>
int Counter<Derived>::count = 0;class WidgetA : public Counter<WidgetA> {};
class WidgetB : public Counter<WidgetB> {};int main() {WidgetA a1, a2;WidgetB b1;std::cout << WidgetA::count << " " << WidgetB::count << std::endl;return 0;
}

A. 2 1
B. 3 1
C. 2 0
D. 1 1

題目 4：CRTP 鏈式調用的實現

以下代碼是否能編譯通過？

template <typename Derived>
class Chainable {
public:Derived& setX(int x) {static_cast<Derived*>(this)->x = x;return *static_cast<Derived*>(this);}
};class Point : public Chainable<Point> {
public:int x, y;Point& setY(int y) { this->y = y; return *this; }
};int main() {Point p;p.setX(10).setY(20);return 0;
}

A. 編譯成功
B. 編譯失敗，setX 返回類型錯誤
C. 編譯失敗，Point 未繼承 Chainable 的正確版本
D. 運行時錯誤

題目 5：CRTP 與模板特化的交互

以下代碼的輸出是什么？

template <typename Derived>
class Base {
public:void print() { std::cout << "Base" << std::endl; }
};template <>
class Base<int> {
public:void print() { std::cout << "Base<int>" << std::endl; }
};class Derived : public Base<Derived> {
public:void print() { std::cout << "Derived" << std::endl; }
};int main() {Derived d;d.print();return 0;
}