C++ 模板(函数模板与类模板)

风陵南·2024-09-05 14:01·589 次阅读

C++ 模板(函数模板与类模板)

模板

模板介绍#

C++提供了函数模板(function template)。所谓函数模板。实际上是建立一个通用函数,其函数类型和形参类型不具体制定,用一个虚拟的类型来代表。这个通用函数就称为函数模板。凡事函数体相同的函数都可以使用这个模板代替,不必定义多个函数,只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型,从而实现不同的函数功能。

C++提供了两种模板机制:函数模板类模板

意义:

  • 模板把函数或类要处理的数据类型参数化,表现为参数的多态性,称为类属。
  • 模板用于表达逻辑结构相同,但具体数据元素类型不同的数据对象的通用行为。

函数模板#

下面举例说明一下函数模板的具体用法。

假设有两个需求:

  • 设计一个函数,实现两个int变量的值的交换
  • 设计一个函数,实现两个double变量的值的交换
Copy
void mySwap(int &a, int &b){
int tmp = a;
a = b;
b = tmp;
}
void mySwap(double &a, double &b){
double tmp = a;
a = b;
b = tmp;
}

如果还有需求要交换其他类型的变量,还需要继续添加函数,而代码几乎一致。并且一旦需求有变更,每个函数都要一个一个修改,非常繁琐且重复。

发现两个函数逻辑结构完全相同,只有变量类型不同,如果能设计一个通用的函数,能够把类型当做参数传递到这个函数中,就简单多了——这就是函数模板

定义#

  • 用法:template<typename T>

template:模板关键字
typename:定义虚拟类型关键字,也可以使用class
T:定义的一个虚拟的类型,在这里暂时不确定是什么类型,等到调用这个函数的时候就可以确定了

Copy
template<typename T>
void mySwap(T &a, T &b){
T tmp = a;
a = b;
b = tmp;
}
int main(){
int a = 10, b = 20;
double x = 3.14, y = 9.9;
// 显式指定类型
mySwap<int>(a, b);
// 可以自动根据实参的类型进行推导
mySwap(a, b);
mySwap(x, y);
cout << "a:" << a << endl;
cout << "b:" << b << endl;
cout << "x:" << x << endl;
cout << "y:" << y << endl;
system("pause");
return 0;
}

函数模板使用案例#

  • 需求
    • 定义一个函数模板,实现对数组中元素进行升序排序
    • 定义一个函数模板,实现将一个数组中元素拼接成为字符串返回
Copy
// 定义一个函数模板,实现对数组中元素进行升序排序
template<class T>
void mySort(T arr[], int len){
for (int i = 0; i < len; i++){
for (int j = i; j < len; j++){
if (arr[i] > arr[j]){
T tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
}
}
// 定义一个函数模板,实现将一个数组中元素拼接成为字符串返回
template<class T>
void showArray(T arr[], int len){
cout << "[";
for (int i = 0; i < len - 1; i++){
cout << arr[i] << ",";
}
cout << arr[len - 1] << "]" << endl;
}
int main(){
// 定义一个int[]
int array1[] = { 1, 3, 5, 7, 9, 0, 8, 6, 4, 2 };
int len1 = sizeof(array1) / sizeof(int);
mySort(array1, len1);
showArray(array1, len1);
// 定义一个double[]
double array2[] = { 3.14, 9.28, 3, 3.44, -9.2, 8.22 };
int len2 = sizeof(array2) / sizeof(double);
mySort(array2, len2);
showArray(array2, len2);
// 定义一个char[]
char array3[] = { 'a', 'l', '1', 'm', 'k' };
int len3 = sizeof(array3) / sizeof(char);
mySort(array3, len3);
showArray(array3, len3);
system("pause");
return 0;
}

函数模板与普通函数#

函数模板和普通函数在调用的时候需要注意:

  • 普通函数的调用是可以发生自动类型转换的;而函数模板调用不允许发生自动类型转换
  • 如果调用函数的时候,实参既可以匹配普通函数,又可以匹配函数模板,则优先匹配普通函数

函数模板重载#

函数模板虽然很通用,但并不是万能的,有时候也会出现不适配的情况

Copy
template<class T>
bool compare(const T& t1, const T& t2) {
return t1 > t2;
}

对于上述函数模板,如果比较的类型设置为自定义类型(如Person类型),则会出现无法比较的问题。

而函数模板的重载,就是为了解决特定对象的问题,通过函数模板的重载,可以为这些特定的数据类型提供具象化的模板

Copy
class Person {
public:
int age;
};
template<class T>
bool compare(const T& t1, const T& t2) {
return t1 > t2;
}
template<>
bool compare<Person>(const Person& p1, const Person& p2) {
return p1.age > p2.age;
}
int main() {
Person p1;
p1.age = 15;
Person p2;
p2.age = 12;
cout << compare(p1, p2) << endl;
return 0;
}

类模板#

类模板和函数模板的定义和使用基本是一样的,但是类模板和函数模板还是有点区别:

  • 类模板不能自动类型推导
Copy
template<class T1, class T2 = int> // 可以使用 = 指定默认类型
class NumberOperator {
public:
T1 num1;
T2 num2;
void cal() {
cout << num1 + num2 << endl;
}
};
int main() {
// 创建对象,不能类型推导,只能自己指定类型
NumberOperator<int, int> op1;
op1.num1 = 10;
op1.num2 = 20;
op1.cal();
// 创建对象
NumberOperator<double> op2; // 默认 T2 = int
op2.num1 = 3.14;
op2.num2 = 10;
op2.cal();
return 0;
}

类模板做函数参数#

Copy
template<class T1, class T2 = int>
class NumberOperation {
public:
T1 num1;
T2 num2;
void cal() {
cout << num1 + num2 << endl;
}
};
// 参数中明确模板类
void useNumberOperation(NumberOperation<int, int>& op) {
op.cal();
}
// 参数中使用模板
template<typename T1, typename T2>
void useNumberOperation02(NumberOperation<T1, T2>& op) {
op.cal();
}
int main() {
// 参数明确模板类调用
NumberOperation<int, int> op;
op.num1 = 10;
op.num2 = 20;
useNumberOperation(op);
// 参数模板
NumberOperation<double, int> op2;
op2.num1 = 10.5;
op2.num2 = 5;
useNumberOperation02(op2);
return 0;
}

类模板继承#

Copy
// 定义模板类
template<typename T>
class Animal {
public:
T arg;
};
// 普通类继承模板类的时候,必须明确指定类型
class Dog: Animal<int> {
// 这里继承到的arg的数据类型是int
};
template<typename E>
class Person: Animal<E> {
// 这里继承到的arg的数据类型是E
};

类模板类外实现#

Copy
template<typename T, typename M>
class NumberCalculator {
private:
T n1;
M n2;
public:
NumberCalculator() {}
NumberCalculator(T n1, M n2);
void add();
};
// 构造函数类外实现
template<typename T, typename M>
NumberCalculator<T, M>::NumberCalculator(T n1, M n2) {
this->n1 = n1;
this->n2 = n2;
}
// 普通函数类外实现
template<typename T, typename M>
NumberCalculator<T, M>::add() {
cout << n1 + n2 << endl;
}

类模板头文件和源文件分离问题#

我们在写程序时,很多时候需要将类的声明和实现分开来写。将类的声明部分写到.h文件中,将类的实现部分写到.cpp文件中。在使用到这个类的时候,直接包含.h文件即可。但当一个类是模板类时,这样做会出现问题。

我们虽然引入了.h文件,但是模板类中的函数是在调用的时候才会创建,因此在编译阶段不会管对应的.cpp文件中的实现部分。
而到了使用这个函数的时候,发现这个函数已经创建了但是没有实现,编译器也会因此而报错。相当于我们只是在.h中声明了函数,但是并没有实现。

解决办法:

  • 使用#include引入.cpp文件
  • 或是将类的声明和实现放到一个文件中(这个文件我们习惯上会定义为.hpp文件,但并不是绝对的,只是一个习惯和约定的问题。)
posted @   风陵南  阅读(593)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 【.NET】调用本地 Deepseek 模型
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
点击右上角即可分享
微信分享提示
目录