C++模板类支持泛型编程，能实现数据类型的参数化，继承则允许子类复用父类的属性和方法，二者结合可以大幅提升代码的复用能力，覆盖更多复杂的开发场景。
模板类与继承的基础特性
模板类的核心是通过<typename T>等参数定义通用逻辑，同一套代码可以适配不同的数据类型，避免为每种类型重复编写相同逻辑。继承则是面向对象的核心特性，子类可以自动拥有父类的非私有成员，还能重写父类方法实现个性化逻辑。
将二者结合时，需要注意模板参数的传递和作用域问题，不同的结合方式适用不同的场景，下面分别介绍三种常见的结合模式。
普通类继承模板类
这种场景下，父类是已经实例化的模板类，子类是普通类，可以直接复用父类的特定类型实现逻辑。
实现示例
先定义一个存储单个数据的模板类，再让普通类继承它的int类型实例化版本：
#include <iostream>
using namespace std;
// 基础模板类，存储单个数据
template <typename T>
class DataHolder {
protected:
T data;
public:
DataHolder(T val) : data(val) {}
T getData() const {
return data;
}
void setData(T val) {
data = val;
}
};
// 普通类继承int类型的DataHolder
class IntDataProcessor : public DataHolder<int> {
public:
IntDataProcessor(int val) : DataHolder<int>(val) {}
// 新增处理int数据的特有方法
int doubleData() const {
return data * 2;
}
};
int main() {
IntDataProcessor processor(10);
cout << "原始数据: " << processor.getData() << endl;
cout << "翻倍后数据: " << processor.doubleData() << endl;
return 0;
}
这种方式的优势是子类不需要关心模板类的泛型实现细节，只需要复用父类针对特定类型的逻辑，适合父类模板已经确定类型的场景。
模板类继承普通类
父类是普通类，定义了通用的基础逻辑，子类是模板类，在父类基础上扩展泛型能力，适配不同的数据类型。
实现示例
先定义一个普通的基础工具类，再让模板类继承它，扩展对不同类型数据的处理能力：
#include <iostream>
#include <string>
using namespace std;
// 普通父类，定义通用的打印前缀逻辑
class BasePrinter {
protected:
string prefix;
public:
BasePrinter(string p) : prefix(p) {}
void printPrefix() const {
cout << prefix << ": ";
}
};
// 模板子类继承普通父类
template <typename T>
class GenericPrinter : public BasePrinter {
private:
T content;
public:
GenericPrinter(string p, T val) : BasePrinter(p), content(val) {}
void print() const {
printPrefix();
cout << content << endl;
}
};
int main() {
GenericPrinter<int> intPrinter("整数", 100);
intPrinter.print();
GenericPrinter<string> strPrinter("字符串", "hello");
strPrinter.print();
return 0;
}
这种方式把通用非泛型逻辑放在父类，泛型逻辑放在子类，职责划分清晰，避免模板类中混入不必要的泛型参数，提升代码可读性。
模板类继承模板类
父类和子类都是模板类，子类可以传递自己的模板参数给父类，或者新增模板参数扩展功能，是复用能力最强的组合方式。
实现示例
定义一个基础容器模板类，再让另一个模板类继承它，新增排序功能：
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// 基础模板容器类
template <typename T>
class BaseContainer {
protected:
vector<T> items;
public:
void addItem(T val) {
items.push_back(val);
}
void printItems() const {
for (auto &item : items) {
cout << item << " ";
}
cout << endl;
}
};
// 模板子类继承模板父类，新增排序功能
template <typename T>
class SortedContainer : public BaseContainer<T> {
public:
void sortItems() {
sort(this->items.begin(), this->items.end());
}
};
int main() {
SortedContainer<int> container;
container.addItem(3);
container.addItem(1);
container.addItem(2);
cout << "排序前: ";
container.printItems();
container.sortItems();
cout << "排序后: ";
container.printItems();
return 0;
}
这种场景下需要注意，子类访问父类的保护成员时，要加上this->前缀，因为模板父类的具体类型在子类实例化时才确定，编译器无法提前识别父类成员的作用域。
结合使用的注意事项
- 模板类的继承中，父类如果是模板类，子类实例化时需要明确父类的模板参数，除非子类也是模板类并传递参数给父类。
- 避免在模板继承中过度嵌套，过多的模板参数会增加代码的编译复杂度和可读性，尽量控制模板参数的数量。
- 父类的析构函数建议声明为虚函数，避免子类对象通过父类指针释放时出现内存泄漏问题。
通过合理组合模板类和继承，开发者可以写出复用性更高、扩展性更好的C++代码，减少重复逻辑，降低后续维护成本。