C++泛型编程——模板

最新推荐文章于 2024-11-12 13:55:23 发布
最新推荐文章于 2024-11-12 13:55:23 发布
阅读量1.4k 收藏 52
点赞数 40
分类专栏： C++学习之路 文章标签： c++ java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l315225/article/details/136071237
版权

C++泛型编程——模板

文章目录


本章思维导图：
在这里插入图片描述

注：本章思维导图对应的xmind和.png文件都已同步导入至资源

1. 泛型编程的概念

在C++中，如果我们不借助库函数，要实现两个数据的交换函数swap，由于要考虑到数据类型的多样性，我们难免要将swap函数重载很多次，例如：

void swap(int& num1, int& num2)
{
	int temp = num1;
	num1 = num2;
	num2 = temp;
}

void swap(char& num1, char& num2)
{
	int temp = num1;
	num1 = num2;
	num2 = temp;
}

void swap(double& num1, double& num2)
{
	int temp = num1;
	num1 = num2;
	num2 = temp;
}

//…………………………

swap函数的函数体基本相同，只有交换数据的类型不同，但就是由于这个小小的不同迫使我们产生很多冗余代码，使生产效率变得低下

为了解决这一问题，C++就支持了泛型编程这一概念：

允许我们用一个通用的代码模板来处理不同类型数据

在C++中，泛型编程就是靠模板来实现的

2. 模板

2.1 模板格式

基本格式为：

template<typename T1, typename T2,......,typename Tn>

  • template为模板的关键字
  • <>里面的即模板参数，代表一个数据类型
  • typename可以用class替代

2.2 函数模板

在这里插入图片描述

基本格式为：

template<typename T1, typename T2,......,typename Tn>

返回值类型 函数名（参数列表）{}

例如：

//定义一个函数模板swap
//T泛指所有类型

template <typename T>
void swap(T& num1, T& num2)
{
	T temp = num1;
	num1 = num2;
	num2 = temp;
}

注意：

当模板函数的声明和定义不能分布在不同的文件

2.3 函数模板的实例化

用不同的类型使用函数模版生成一个具体的函数这一过程叫做函数模板的实例化，函数模板的实例化有以下两种方法：

2.3.1 隐式（推演）实例化

推演实例化——让编译器根据实参推演模板参数的实际类型

例如：

template <typename T>
void swap(T& num1, T& num2)
{
	T temp = num1;
	num1 = num2;
	num2 = temp;
}


int main()
{
	int a = 1, b = 2;
	double a1 = 1.0, b1 = 2.0;

	swap(a, b);	//实例化函数模板为swap(int& num1, int& num2)，并进行调用
	swap(a1, b1);	//实例化函数模板为swap(double& num1, double& num2)，并进行调用

	return 0;
}

需要注意：
如果该函数模板的模板参数只有一个，那么进行推演实例化时，传入的实参的类型就只能有一个（即模板不允许自动类型转换

例如：

template <typename T>
void swap(T& num1, T& num2)
{
	T temp = num1;
	num1 = num2;
	num2 = temp;
}

int main()
{
	int a = 1;
	double b = 2.0;
	swap(a, b);

	return 0;
}

//会报错：
// “swap”: 未找到匹配的重载函数
// “void swap(T &,T &)”: 模板 参数“T”不明确

为了避免这个问题，一种解决方式就是增多模板参数：

template <typename T1, typename T2>
void swap(T1& num1, T2& num2)
{
	T1 temp = num1;
	num1 = num2;
	num2 = temp;
}

int main()
{
	int a = 1;
	double b = 2.0;
	swap(a, b);

	return 0;
}

一种方法是使用强制类型转换，使传入的类型相同。但这个方法也有一个需要注意的点：如果函数模板的形参为引用类型，但是没有被const修饰，那么就不能用强制类型转换来实现推演实例化：

template <typename T>
void swap(T& num1, T& num2)
{
	T temp = num1;
	num1 = num2;
	num2 = temp;
}

int main()
{
	int a = 1;
	double b = 2.0;

	swap(a, (int)b);
 //(int)b涉及数据类型的转换，因此产生了一个临时变量，而临时变量具有常性（const）,
 //被const修饰的引用权限不能被放大，因此无法转换为没有被const修饰的形参T& num

	return 0;
}

还有一种常用的方法就是使用显式实例化

2.3.2 显式实例化

显式实例化——在函数名后的<>中指定模板参数的实际类型

注意：使用显式实例化同样需要注意引用权限不能提升的问题

例如：

template <typename T>
T Add(const T& num1, const T& num2)
{
	return num1 + num2;
}

int main()
{
	int a1 = 1, b1 = 2;
	double a2 = 2.0, b2 = 4.99;

	int ret1 = Add<int>(a1, a2);
	double ret2 = Add<double>(b1, b2);

	return 0;
}

2.3 类模板

在这里插入图片描述

基本格式：

template<typename T1, typename T2,......,typename Tn>

class 类模板名 {}；

例如：

//定义一个类模板stack
//该stack可以存储所有类型

template <class T>
class stack
{
public:
	stack(int capacity = 3)
	{
		_a = new T[capacity];
		_capacity = capacity;
		_top = 0;
	}

	void push(T val) {}

	//…………

private:
	T* _a;
	int _capacity;
	int _top;
};

类模板只能显示实例化，其基本格式为：

类模板名 <数据类型> 对象名

例如对于上面的类模板stack：

stack<int> st1;
stack<double> st2;

类成员函数声明和定义分离：

template <class T>
class stack
{
public:
	stack(int capacity = 3)
	{
		_a = new T[capacity];
		_capacity = capacity;
		_top = 0;
	}

	void push(T val);

	//…………

private:
	T* _a;
	int _capacity;
	int _top;
};

//当声明和定义分离时，需要制定成员函数所在类的类型
//类模板的类模板名不是类名，类模板名<数据类型>才是类类型
//同样，成员函数的声明和定义不能分在两个不同的文件
template <class T>
void stack<T>::push(T val) {}

2.4 非类型模板参数

在这里插入图片描述

模板的参数列表支持传入非类型模板参数，以供在类模板或者函数模板的内部直接使用。

例如:

template<class T, size_t N = 10>
void func(T a)
{
	cout << N << endl;
}

int main()
{
	func(1);
	return 0;
}

output:

10

这里需要注意：

  • 非类型模板参数只能是整形数据，即size_t, int, char等类型
  • 非类型模板参数必须在编译时就能确定结果，因此只能是常量
  • 即非类型模板参数只能是整型常量

2.5 模板的特化

有小伙伴会问：什么是模板的特化？

我们先来看下面的代码：

template<class T>
bool Less(T a, T b)
{
	return a < b;
}

int main()
{
	string str1 = "a";
	string str2 = "b";
	string* ptr1 = &str1;
	string* ptr2 = &str2;

	cout << Less(str1, str2) << endl;
	cout << Less(ptr1, ptr2) << endl;

	return 0;
}

output:

1
0

  • 我们定义了两个string对象：str1“a”和str2”b“，并用两个指针ptr1和ptr2分别指向这两个对象

  • 我们调用函数模板Less欲比较对象str1和str2以及指针ptr1和ptr2所指向对象的大小

  • 比较str1和str2时，字符串“a”确实小于字符串“b”，也得到了正确的结果：1

  • 比较ptr1和ptr2时，确得到了相反的结果：0。这是为何？这是因为，我们传入函数模板的类型为string*，是一个指针类型，因此函数Less比较的也是两个指针的大小，而栈区的地址从高到低使用的，因此输出0。

可见第二次比较与我们比较两指针指向的内容的本意不符，因此我们要对string*这一特殊情况进行处理，也就是模板的特化。

简单点来说，模板特化就是：

原模板类的基础上，针对特殊类型所进行特殊化的实现方式

模板的特化分为函数模板的特化以及类模板的特化

2.5.1 函数模板的特化

在这里插入图片描述

要进行函数模板的特化，首先必须要有一个基础的函数模板

特化的基本格式为：

  • template后面跟一个空的<>，即template<>
  • 函数名后面跟一个<>，里面为特化的具体类型
  • 函数的参数列表必须要和原函数模板的参数列表的格式一致

例如对于上面的Less，我们对类型string*进行特化：

template<class T>
bool Less(T a, T b)
{
	return a < b;
}

template<>
bool Less<string*>(string* a, string* b)
{
	return *a < *b;	//比较的是指针指向的内容
}

事实上，为了提高代码的可读性，如果我们要对函数参数的某一特定类型进行特殊处理，我们为往往会以函数重载的方式解决：

bool Less(string* a, string* b)
{
	return *a < *b;
}

因此，函数模板的特化实际上并不常用

2.5.2 类模板的特化

在这里插入图片描述

类模板的特化分为全特化和偏特化两种：

2.5.2.1 全特化

全特化即是将模板参数列表中所有的参数都确定化

格式为：

  • template后面跟一个空的<>，即template<>
  • 类模板名后面跟一个<>，里面为特化的具体类型

例如：

template<class T1, class T2>
class A
{
public:
	void func()
	{
		cout << "A" << endl;
	}
};

template<>
class A<int, int>
{
public:
	void func()
	{
		cout << "A<int, int>" << endl;
	}
};
int main()
{
	A<int, int> a1;
	A<double, int> a2;
	a1.func();
	a2.func();

	return 0;
}

output:

A<int, int>
A
2.5.2.2 偏特化

全特化即是将模板参数列表中部分参数确定化

偏特化又分为两种，一种是确定部分参数的类型，一种是确定部分或所有参数的性质。我们分开来说明：

确定部分参数的类型

格式为：

  • template后面跟一个<>，里面为不要被确定的模板参数
  • 类模板名后面跟一个<>，里面为不要被确定的模板参数以及被确定的具体类型

例如：

template<class T1, class T2>
class A
{
public:
	void func()
	{
		cout << "A" << endl;
	}
};

template<class T1>
class A<T1, char>
{
public:
	void func()
	{
		cout << "A<T1, char>" << endl;
	}
};

template<class T2>
class A<double, T2>
{
public:
	void func()
	{
		cout << "A<double, T2>" << endl;
	}
};

确定部分或全部参数的性质

这里的性质指的就是指针或者引用或者普通类型

格式为：

  • template后面跟一个<>，里面的内容和原类模板一致
  • 类模板名后面跟一个<>，里面为确定的参数性质

例如：

template<class T>
struct Less
{
	bool operator() (T a, T b)
	{
		return a < b;
	}
};

//只要传入的类型为指针类型，那么就会用这个模板
template <class T>
struct Less<T*>
{
	bool operator() (T* a, T* b)
	{
		return *a < *b;
	}
};

3. 模板的本质

  • 和类实例化对象类似，我们不能将类看成是一个具体的对象，它只是一个不占据空间的蓝图

  • 同样，我们也不能将函数模板和类模板看成是一个具体的函数和类，他们也只是实例化一个具体函数和类的模具

  • 只有我们使用一个或多个具体的数据类型用模板实例化时，才会形成一个具体的函数和类。

在这里插入图片描述

如上图所示， 在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。因此实际上，我们没写的冗余代码，编译器都替我们完成了，是编译器在替我们负重前行。

Forward♞
关注
专栏目录
C++泛型编程——模板初阶
weixin_46016019的博客
03-01 1551
C++泛型编程，了解模板的使用与原理
【C++】泛型编程——模板初阶
m0_70980326的博客
02-28 1960
泛型编程——模板初阶：函数模板的概念、使用、原理、实例化、匹配原则；类模板
C++ 泛型编程——模板
何亮5083的博客
12-09 124
文章目录C++模板类模板函数模板类模板中的全特化和偏特化全特化参数的偏特化范围的偏特化成员模板 C++模板 模板有类模板，函数模板和成员模板。 类模板 template <typename T> class complex { public: complex(T r = 0, T i = 0) :re(r), im(i) {} T real() const { return re; } T imag() const { return im; } private: T re, im;
【C++】泛型编程——模板进阶
m0_70980326的博客
06-24 755
泛型编程——模板进阶：非类型模板参数、模板的特化、模板的分离编译
C++泛型编程1——函数模板实例化，模板参数，重载及特化
lixungogogo的博客
08-13 6403
在C++中我们都知道引入了函数重载，那么在实际应用过程中： 　　如果我们想要实现一个加法函数，我们可以写出很简单的代码： 　　int ADD(int a,int b) { 　　return a+b; }　　上面的函数很简单，但是仔细想一下，这样就实现了加法操作嘛？当我们的实参类型为double，float时，又怎么处理加法呢？ 　　我们可以多定义几个函数 　　double ADD(doubl
C++的泛型编程—模板
qq_63440853的博客
12-21 1137
详细的描述了函数模板，类模板的用法，概念，即如何实例化。以及模板特化的知识点
「C++」泛型编程 —— 函数模版
太初有泪的博客
12-31 219
函数模版1. 简介2. 函数模版3. 函数模版实例化4. 参考列表 模版（Template）是C++中泛型编程的基础。一个模版就是一个创建类或函数的蓝图。模板采用类型作为参数，支持通用程序设计。以下仅为常用形式，其它的内容如非类型参数形式，可以查阅参考列表。 1. 简介 泛型编程有够处理在编写程序时不知道类型的情况，是独立于任务特定类型的程序设计，而模版是泛型编程的基础。假如我们要编写一个函数来比较两个对象的值，并给出小于、等于或大于的结果，因为对象的类型未知，可能需要根据其类型定义多个重载函数，但这些
c++泛型编程-模板
bhbca的博客
02-15 70
c++泛型编程——模板
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 1179
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
STL set
hls0611的博客
11-09 249
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
C 学习（4）
search7的博客
11-05 886
C语言学习，每个模块来自工作中的？？？
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 258
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 389
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++——智能指针
最新发布
Wangx_wang的博客
11-12 600
介绍了几种智能指针的不同和实现思路以及循环引用的问题
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
caridle的专栏
11-08 716
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 332
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
【Effective C++】阅读笔记5
gma999的博客
11-07 920
Effective C++ 面向对象和模板相关章节
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Forward♞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值