模板实现的多态是编译期多态，行为在编译时确定，无运行时开销；而虚函数实现的是运行时多态，通过vtable动态绑定。若需用模板模拟运行时多态，可采用CRTP或类型擦除技术。CRTP通过基类模板接收派生类为模板参数，在编译时实现静态多态，支持接口强制与零成本抽象；类型擦除则通过模板构造函数封装不同类型于统一接口后，以虚函数实现运行时多态，如std::any、std::function。此外，策略模式等基于模板的设计也提升了行为的可配置性。
C++中，模板实现的多态行为与我们通常理解的基于虚函数的运行时多态有着根本性的区别。简单来说，模板提供的是一种编译期多态，或者叫静态多态。它允许我们编写泛型代码，这些代码能够处理多种数据类型，而具体的类型绑定和行为选择是在编译时就确定下来的。如果你想用模板来模拟运行时多态，那通常需要借助一些更高级的模式，比如奇异递归模板模式（CRTP）或是类型擦除（Type Erasure）技术。
解决方案
要深入理解C++如何利用模板实现（或模拟）多态行为，我们首先得区分清楚静态多态和动态多态。传统的C++多态，也就是我们常说的基于虚函数的运行时多态，其核心在于通过基类指针或引用在运行时调用派生类的特定实现。这依赖于虚函数表（vtable）和动态绑定。
而模板带来的，是另一种完全不同的多态形式：编译期多态。它通过参数化类型，让同一份代码逻辑能够适配不同的类型。比如一个函数模板
template <typename T> void process(T& obj)，当你用
int调用它，编译器会生成一份处理
int的代码；当你用
MyClass调用，又会生成一份处理
MyClass的代码。这里的“多态”体现在一个泛型接口可以作用于多种类型，但所有具体的行为都是在编译时就确定并硬编码到最终的可执行文件中的。这意味着没有运行时查找的开销，通常性能会更高。
然而，如果我们的目标是让一个容器能存储不同类型的对象，并在运行时统一调用它们的某个“共同”方法，而这些类型之间并没有显式的继承关系，或者我们想避免虚函数的开销，模板就能派上用场了。CRTP和类型擦除就是两种主要的技术路径。
立即学习“C++免费学习笔记（深入）”；
静态多态与运行时多态：核心差异在哪里？
在我看来，理解模板多态的关键在于区分“何时”决定行为。运行时多态（虚函数）是在程序执行时，根据对象的实际类型来决定调用哪个函数版本。这就好比你有一个“交通工具”的遥控器，按“启动”键，它会根据当前是汽车、飞机还是船来执行各自的启动逻辑。这种灵活性是以一定的运行时开销（vtable查找、动态内存分配等）为代价的。
而模板实现的静态多态，所有的行为决策都在编译阶段完成。当编译器看到你用
std::vector<int>或者
std::vector<std::string>时，它会为每种类型生成一套完全独立的代码。这里没有一个统一的“交通工具”遥控器，而是针对每种交通工具都有一套独立的遥控器和操作手册。好处是零运行时开销，性能极致；缺点是编译时必须知道所有类型，无法在运行时动态处理未知类型。
例如，
std::sort就是一个典型的模板函数，它可以对任何满足特定条件的容器进行排序。它并不知道具体要排序的是
int还是
double，但在编译时，它会根据你传入的类型生成对应的排序逻辑。这就是模板带来的强大泛型能力，它让代码复用变得高效且类型安全。
CRTP（奇异递归模板模式）如何模拟多态行为？
CRTP是一种非常巧妙的模板使用模式，它允许派生类作为模板参数传递给其基类。它的基本形式是
template <typename Derived> class Base { /* ... */ }; class MyDerived : public Base<MyDerived> { /* ... */ };。这看起来有点像“鸡生蛋，蛋生鸡”的递归，但它在编译时就能提供一些运行时多态的特性，而且没有虚函数的开销。
CRTP的核心思想是，基类模板
Base可以通过
static_cast将自身指针或引用转换为派生类
Derived的指针或引用，从而调用派生类的方法。这在编译时是安全的，因为
Base模板在实例化时就已经知道
Derived的具体类型了。
考虑一个简单的例子，我们想强制所有派生类都实现一个
clone()方法，但又不想用虚函数：
template <typename Derived>
class Cloneable {
public:
// 这是一个非虚接口，但它会调用派生类的具体实现
Derived* clone() const {
// 通过 static_cast 将 *this 转换为 Derived 类型
// 然后调用 Derived 类的 do_clone() 方法
return static_cast<const Derived*>(this)->do_clone();
}
protected:
// 派生类必须实现这个方法
// 注意：这里没有纯虚函数，因为这不是虚函数机制
Cloneable() = default;
~Cloneable() = default;
Cloneable(const Cloneable&) = default;
Cloneable& operator=(const Cloneable&) = default;
};
class MyConcreteClass : public Cloneable<MyConcreteClass> {
public:
MyConcreteClass() : value_(0) {}
MyConcreteClass(int val) : value_(val) {}
// 派生类必须实现的具体克隆逻辑
MyConcreteClass* do_clone() const {
return new MyConcreteClass(*this);
}
void print() const {
std::cout << "MyConcreteClass value: " << value_ << std::endl;
}
private:
int value_;
};
// 使用示例
// MyConcreteClass obj(10);
// MyConcreteClass* cloned_obj = obj.clone(); // 调用的是 MyConcreteClass::do_clone()
// cloned_obj->print(); // 输出 MyConcreteClass value: 10
// delete cloned_obj;在这个例子中，
Cloneable基类提供了一个
clone()接口，它内部通过
static_cast调用了派生类
MyConcreteClass的
do_clone()方法。如果
MyConcreteClass没有实现
do_clone()，编译器就会报错，从而实现了编译期接口检查。这是一种非常有效的“静态多态”形式，它在编译时强制了派生类的行为，同时避免了运行时虚函数调用的开销。CRTP也常用于实现混入（mixins）、静态策略选择等场景。
除了CRTP，还有哪些基于模板实现多态的进阶技巧？
当CRTP无法满足需求，或者我们需要真正的运行时多态但又想避免传统继承体系的束缚时，类型擦除（Type Erasure）就浮出水面了。类型擦除是一种更高级、也更复杂的模板技巧，它允许你存储和操作不同类型的对象，而这些对象在接口层面表现出一致性，但在底层它们的具体类型信息被“擦除”了。这听起来有点玄乎，但其实我们日常使用的
std::function、
std::any就是典型的类型擦除实现。
类型擦除的核心思想是：
- 定义一个抽象的概念（Concept），它包含我们希望所有“擦除”后的类型都能支持的操作。
- 为每种具体类型（Model）实现这个Concept。
- 使用一个“外壳”类（Wrapper）来持有这些Model，并提供统一的接口。这个Wrapper通常会使用模板来构造，从而捕获具体类型。
举个简化版的
std::any的例子，假设我们想创建一个可以存储任意类型，并能打印其值的容器：
#include <iostream>
#include <memory>
#include <string>
#include <vector>
class AnyPrintable {
private:
// 抽象概念接口
struct Concept {
virtual ~Concept() = default;
virtual void print() const = 0;
virtual std::unique_ptr<Concept> clone() const = 0; // 考虑复制
};
// 具体类型模型
template <typename T>
struct Model : Concept {
T value;
Model(T val) : value(std::move(val)) {}
void print() const override {
std::cout << value << std::endl;
}
std::unique_ptr<Concept> clone() const override {
return std::make_unique<Model<T>>(value);
}
};
std::unique_ptr<Concept> ptr_;
public:
// 模板构造函数，捕获任意类型 T
template <typename T>
AnyPrintable(T value) : ptr_(std::make_unique<Model<T>>(std::move(value))) {}
// 默认构造和析构
AnyPrintable() = default;
~AnyPrintable() = default;
// 拷贝构造和赋值（需要实现深拷贝）
AnyPrintable(const AnyPrintable& other) {
if (other.ptr_) {
ptr_ = other.ptr_->clone();
}
}
AnyPrintable& operator=(const AnyPrintable& other) {
if (this != &other) {
if (other.ptr_) {
ptr_ = other.ptr_->clone();
} else {
ptr_.reset();
}
}
return *this;
}
// 统一的接口
void print() const {
if (ptr_) {
ptr_->print();
} else {
std::cout << "[empty]" << std::endl;
}
}
};
// 使用示例
// AnyPrintable a(10);
// AnyPrintable b(std::string("hello world"));
// AnyPrintable c(3.14);
// AnyPrintable d = a; // 拷贝构造
//
// a.print(); // 输出 10
// b.print(); // 输出 hello world
// c.print(); // 输出 3.14
// d.print(); // 输出 10
//
// std::vector<AnyPrintable> collection;
// collection.push_back(1);
// collection.push_back("test");
// collection.push_back(2.5f);
//
// for (const auto& item : collection) {
// item.print();
// }
// 输出:
// 1
// test
// 2.5在这个
AnyPrintable的例子中，模板构造函数
AnyPrintable(T value)是关键。它接收任何类型的
T，然后将其封装在一个
Model<T>对象中，而
Model<T>又继承自
Concept。这样，无论你传入什么类型，
AnyPrintable内部都通过一个
std::unique_ptr<Concept>来管理，从而实现了在运行时调用统一的
print()方法，尽管底层是完全不同的类型。这就是真正的运行时多态，但它巧妙地利用了模板来构建其内部的类型适配器。
除了类型擦除，还有一些基于模板的策略模式（Policy-Based Design），虽然不直接叫“多态”，但它通过模板参数来选择不同的算法或行为策略，从而在编译时组装出具有不同行为的类。比如Loki库中的各种组件，就是策略模式的经典应用。它们通过模板参数将不同的行为注入到类中，实现了高度的灵活性和可配置性，这在某种程度上也体现了模板在构建灵活、可变行为上的强大能力。
