C++中模板类与继承结合可实现静态与运行时多态融合、避免重复代码并提升类型安全，典型应用为CRTP模式，它通过基类模板接受派生类为参数，在编译期完成多态调用，消除虚函数开销，同时支持通用功能注入；此外，模板化基类与具体派生类结合可实现接口统一与数据类型泛化，适用于策略模式等场景，兼顾灵活性与性能。
C++中模板类与继承的结合，其核心在于在保持类型安全和编译期性能的同时，实现高度灵活且可扩展的代码复用。在我看来，这不仅仅是两种语言特性简单的叠加，更像是两种不同哲学思想的交汇：继承强调“is-a”的关系和运行时多态，而模板则侧重于“has-a”的结构和编译期泛型。当它们巧妙地融合，我们就能构建出既能适应多种数据类型，又能展现复杂行为逻辑的强大系统。这就像是给一个通用的骨架（模板）注入了生命力（继承），使其能够以多种形态（具体类型）运行，并且保持其核心的通用性。
要实现C++模板类与继承的结合以达到复用目的，我们可以从几个不同的角度切入，但最典型的实践之一就是奇异递归模板模式（CRTP），它利用模板参数将派生类作为基类的模板参数，从而在编译期实现静态多态。另一种常见方式是使用模板化的基类来定义通用接口或行为，然后由具体的非模板派生类继承并实现，或者反过来，一个非模板基类定义多态接口，而其派生类是模板化的。这两种策略各有侧重，CRTP更偏向于在编译期注入通用功能并利用派生类的特定实现，而后者则更多地是为了在运行时处理不同类型的数据，同时保持接口的统一。
说实话，当我初次接触C++模板和继承时，我曾觉得它们是各司其职的，一个解决类型泛化，一个解决行为泛化。但实践中，我发现它们单独使用时都有各自的局限。纯粹的继承往往意味着基类需要处理固定类型的数据，或者通过
void*
std::any
std::vector<Base*>
将它们结合起来，我认为主要解决了以下几个代码复用难题：
立即学习“C++免费学习笔记（深入）”；
静态多态与运行时多态的巧妙融合： CRTP就是一个很好的例子，它允许基类在编译期“知道”派生类的类型，从而可以调用派生类的方法，实现一种零开销的“静态多态”。这对于那些需要高性能、避免虚函数开销的场景非常有用。同时，我们也可以设计一个模板化的基类，其内部包含虚函数，这样派生类既可以享受模板带来的类型泛化，又能在运行时通过虚函数实现多态行为。这就像是给代码库注入了两种不同的生命力，各取所长。
避免重复实现，同时保持类型安全： 想象一下，你有一组操作，它们逻辑上非常相似，只是处理的数据类型不同。如果只用继承，你可能需要为每种数据类型创建一套独立的类层次结构；如果只用模板，你可能无法在运行时统一管理这些不同类型的对象。通过结合，我们可以将通用算法或辅助功能放在模板基类中实现，让派生类专注于其特有的类型细节，从而大幅减少代码冗余，并且在编译期就能捕获类型错误，而不是等到运行时才发现问题。
策略化与可配置性： 这种结合为实现策略模式、桥接模式等设计模式提供了更强大的工具。我们可以用模板参数来注入不同的“策略”或“行为”，而继承则可以定义这些策略的通用接口或基础结构。这样，一个核心组件可以根据模板参数在编译时配置其行为，同时又能通过继承和虚函数在运行时动态切换或扩展功能。这使得系统变得极其灵活，能够轻松适应需求变化。
在我看来，CRTP（Curiously Recurring Template Pattern，奇异递归模板模式）是C++模板和继承结合中最具代表性、也最令人着迷的模式之一。它初看起来有点反直觉，基类模板居然以派生类作为模板参数，但这正是其强大之处。
它的基本思想是：一个基类模板
Base<Derived>
Derived
Base<Derived>
#include <iostream>
#include <string>
#include <vector>
// 示例1: 为派生类注入通用功能（如计数）
template <typename Derived>
class Counted {
public:
Counted() {
++s_count;
// 尝试通过静态转换访问派生类的一些特性，如果需要
// static_cast<Derived*>(this)->onCreation();
}
~Counted() {
--s_count;
// static_cast<Derived*>(this)->onDestroy();
}
static size_t getCount() {
return s_count;
}
private:
static size_t s_count;
};
template <typename Derived>
size_t Counted<Derived>::s_count = 0;
class MyObject : public Counted<MyObject> {
public:
MyObject() {
std::cout << "MyObject created. Total MyObjects: " << getCount() << std::endl;
}
~MyObject() {
std::cout << "MyObject destroyed. Total MyObjects: " << getCount() << std::endl;
}
};
class AnotherObject : public Counted<AnotherObject> {
public:
AnotherObject() {
std::cout << "AnotherObject created. Total AnotherObjects: " << getCount() << std::endl;
}
~AnotherObject() {
std::cout << "AnotherObject destroyed. Total AnotherObjects: " << getCount() << std::endl;
}
};
// 示例2: 静态多态 - 基类调用派生类方法
template <typename Derived>
class Shape {
public:
void draw() {
// 在基类中实现通用逻辑
std::cout << "Drawing a shape: ";
// 通过静态转换调用派生类的特定实现，实现静态多态
static_cast<Derived*>(this)->doDraw();
}
protected:
// 保护构造函数，强制通过派生类创建
Shape() = default;
// 派生类必须实现 doDraw() 方法
};
class Circle : public Shape<Circle> {
public:
void doDraw() {
std::cout << "Circle" << std::endl;
}
};
class Square : public Shape<Square> {
public:
void doDraw() {
std::cout << "Square" << std::endl;
}
};
// 使用
// int main() {
// MyObject o1, o2;
// AnotherObject a1;
// {
// MyObject o3;
// std::cout << "Current MyObjects: " << MyObject::getCount() << std::endl;
// } // o3 destroyed
// std::cout << "Final MyObjects: " << MyObject::getCount() << std::endl;
// std::cout << "Final AnotherObjects: " << AnotherObject::getCount() << std::endl;
//
// Circle c;
// Square s;
// c.draw(); // Calls Circle::doDraw via Shape<Circle>::draw
// s.draw(); // Calls Square::doDraw via Shape<Square>::draw
//
// // 注意：不能通过基类指针或引用进行运行时多态调用
// // Shape<Circle>* p = &c; // 编译错误，因为Shape<Circle>和Shape<Square>是不同的类型
//
// return 0;
// }CRTP的优点在于：
doDraw()
draw()
然而，CRTP也有其局限性，我个人觉得最明显的是：
Shape<Circle>
Shape<Square>
std::vector<Shape*>
Circle
Square
总的来说，CRTP是一个非常强大的工具，特别适用于那些需要在编译期进行高度优化和类型安全抽象的场景。但如果你的需求是运行时多态，那么你可能需要考虑其他结合方式。
除了CRTP这种偏向于静态多态的模式，C++模板和继承的结合在其他场景中也展现出强大的协同效应，尤其是在需要运行时多态，但又希望操作的数据类型是泛型的情况下。
模板化的抽象基类与具体派生类： 这种模式下，我们有一个抽象的基类（可能本身就是模板化的），它定义了一组虚函数接口。然后，具体的派生类继承这个基类，并实现这些虚函数。这里的关键是，基类或派生类可以利用模板参数来处理不同类型的数据，同时保持了运行时多态的能力。
#include <iostream>
#include <string>
#include <vector>
#include <memory> // For std::unique_ptr
// 模板化的抽象基类，定义处理特定类型T的接口
template <typename T>
class DataProcessor {
public:
virtual ~DataProcessor() = default; // 虚析构函数是实现多态的关键
virtual void process(T& data) = 0;
virtual void display(const T& data) const = 0;
};
// 具体的派生类，处理int类型
class IntMultiplier : public DataProcessor<int> {
public:
void process(int& data) override {
std::cout << "Multiplying int: " << data << " by 2." << std::endl;
data *= 2;
}
void display(const int& data) const override {
std::cout << "Current int value: " << data << std::endl;
}
};
// 具体的派生类，处理std::string类型
class StringAppender : public DataProcessor<std::string> {
public:
void process(std::string& data) override {
std::cout << "Appending to string: \"" << data << "\"." << std::endl;
data += " (processed)";
}
void display(const std::string& data) const override {
std::cout << "Current string value: \"" << data << "\"" << std::endl;
}
};
// 使用示例
// int main() {
// int int_val = 10;
// std::string str_val = "Hello";
//
// // 使用unique_ptr管理多态对象
// std::unique_ptr<DataProcessor<int>> intProcessor = std::make_unique<IntMultiplier>();
// std::unique_ptr<DataProcessor<std::string>> stringProcessor = std::make_unique<StringAppender>();
//
// intProcessor->display(int_val);
// intProcessor->process(int_val);
// intProcessor->display(int_val);
//
// std::cout << "--------------------" << std::endl;
//
// stringProcessor->display(str_val);
// stringProcessor->process(str_val);
// stringProcessor->display(str_val);
//
// // 注意：你不能把 DataProcessor<int>* 和 DataProcessor<std::string>* 放在同一个容器里
// // 因为它们是不同的类型。如果你需要处理多种类型的数据，可能需要类型擦除或variant。
//
// return 0;
// }这种模式的优势在于：它允许你为不同的数据类型创建专门的处理器，同时这些处理器都遵循一个通用的接口。你可以在运行时根据需要创建并使用这些处理器。虽然
DataProcessor<int>
DataProcessor<std::string>
std::vector<DataProcessor*>
IntMultiplier
StringAppender
策略模式与模板参数： 虽然策略模式本身不一定需要继承，但当策略的实现方式依赖于某种通用行为接口时，继承就派上用场了。而模板则可以用来选择不同的策略。
例如，一个
FileHandler
EncryptionStrategy
AESEncryption
XOREncryption
FileHandler
// 假设有加密策略接口和实现
class EncryptionStrategy {
public:
virtual ~EncryptionStrategy() = default;
virtual std::string encrypt(const std::string& data) const = 0;
virtual std::string decrypt(const std::string& data) const = 0;
};
class AESEncryption : public EncryptionStrategy {
public:
std::string encrypt(const std::string& data) const override {
return "AES_ENCRYPTED(" + data + ")";
}
std::string decrypt(const std::string& data) const override {
return data.substr(14, data.length() - 15); // Simplified
}
};
class XOREncryption : public EncryptionStrategy {
public:
std::string encrypt(const std::string& data) const override {
return "XOR_ENCRYPTED(" + data + ")";
}
std::string decrypt(const std::string& data) const override {
return data.substr(14, data.length() -以上就是C++模板类与继承结合实现复用的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告
收藏
收藏
收藏
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
541
