C++模板(初阶+进阶)

最新推荐文章于 2023-08-15 17:08:17 发布
最新推荐文章于 2023-08-15 17:08:17 发布
阅读量587 收藏
点赞数 2
分类专栏： C++ 文章标签： c++ 开发语言 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57675461/article/details/123927554
版权

文章目录

模板初阶

一、泛型编程

如何实现一个通用的交换函数呢？

void Swap(int& left,int&right)
{
	int tmp = left;
	left = right;
	right = tmp;
}
void Swap(double& left, double& right)
{
	double tmp = left;
	left = right;
	right = tmp;
}
void Swap(char& left, char& right)
{
	char tmp = left;
	left = right;
	right = tmp;
}
//....

 我们可以利用函数重载实现通用的交换函数，但是却有几个缺点：

  1. 重载函数仅仅只是参数类型不同，代码的复用率比较低，只要有新的类型出现，我们都需要重新手动书写
  2. 代码的可维护性比较低，一个出错可能所有的重载都会出错
    那么能否告诉编译器一个模子，让编译器根据不同的类型，利用该模子自动生成代码？
    在这里插入图片描述
     就像我们的蛋糕模具一样，作出了模具，以后都不需要手工亲自动手，拿模板一盖，想要的各种类型都出来了。
    如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件 (生成具体类型的代码），那将会节省许多头发。
     巧的是前人早已将树栽好，我们只需在此乘凉。
    泛型编程：编写与类型无关的通用代码，是代码复用的一种手段，模板是泛型编程的基础。
    在这里插入图片描述

二、函数模板

2.1函数模板的概念

 函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

2.2函数模板格式

template<class T1,class T2,..... >
返回值类型 函数名(参数列表)
{}

注意：其中的class是用来定义模板参数的关键字，也可以使用typename，切记不能使用struct代替class
举个例子：

template <class T>
void Swap(T& left,T& right)
{
	T tmp = left;
	left = right;
	right = tmp;
}
int main()
{
	int a = 2;
	int b = 3;
	Swap(a,b);

	return 0;
}

2.3函数模板的原理

 其实就和我们平常做蛋糕一样，用模具帮我们完成一些重复的工作。函数模板是一个蓝图，它本身不是函数，是编译器用使用方式产生特定类型具体类型的函数的模具，其实模具就是将本来应该人手动做的事情交给了编译器帮我们完成重复的工作。
在这里插入图片描述
 在编译阶段，对于函数模板的使用，编译器需要根据传入的实参类型，来推演生成对应的函数以供调用。例如：传入int类型使用函数模板时，编译器通过实参类型推演，将T确定为int类型，然后产生一份专门处理int类型的代码。具体编译器是怎么做到的我们没有必要深究。

2.4函数模板的实例化

 用不同类型的参数使用函数模板时，称为函数模板的实例化。
模板参数实例化分为：隐式实例化和显示实例化
①隐式实例化：让编译器根据实参推演模板参数的实际类型

template<class T> 
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.0, d2 = 20.0;
	Add(a1, a2);
	Add(d1, d2);
	// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
	Add(a1, (int)d1);
	return 0;
}

 该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错
注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅Add(a1, d1);

②显示实例化：在函数名后面，加个< >，在里面指定模板参数的实际类型

int main(void)
{
	int a = 10;
	double b = 20.0;

	// 显式实例化
	Add<int>(a, b);//两个实参指定为int类型
	return 0;
}

2.5模板参数匹配原则

 ①一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

// 专门处理int的加法函数
int Add(int left, int right) {
	return left + right;
}
// 通用加法函数
template<class T> T Add(T left, T right) {
	return left + right;
}
void Test()
{
	Add(1, 2); // 与非模板函数匹配，编译器不需要特化
	Add<int>(1, 2); // 调用编译器特化的Add版本
}

 ②对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

// 专门处理int的加法函数
int Add(int left, int right) {
	return left + right;
}
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right) {
	return left + right;
}
void Test()
{
	Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
	Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}

 ③模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

三、类模板

3.1类模板定义格式

template<class T1, class T2, ..., class Tn>
class 类模板名
{
	// 类内成员定义
};

举例：

// 动态顺序表
// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
template<class T>
class Vector
{
public:
	Vector(size_t capacity = 10)
		: _pData(new T[capacity])
		, _size(0)
		, _capacity(capacity)
	{}

	// 使用析构函数演示：在类中声明，在类外定义。
	~Vector();

	void PushBack(const T& data)；
		void PopBack()；
		// ...

		size_t Size() { return _size; }

	T& operator[](size_t pos)
	{
		assert(pos < _size);
		return _pData[pos];
	}

private:
	T* _pData;
	size_t _size;
	size_t _capacity;
};
// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template <class T>
Vector<T>::~Vector()
{
	if (_pData)
		delete[] _pData;
	_size = _capacity = 0;
}

3.2类模板实例化

 类模板实例化与函数模板实例化不同，对于函数模板而言，模板实例化之后，会生成一个真正的函数。而类模板经过实例化之后，只是完成了类的定义，模板类的成员函数需要到调用时才会被初始化，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

//Vector是类名，Vector<int>才是类型
vector<int> v1;
Vector<double> v2;

模板进阶

一、非类型模板参数

模板参数分为：

  • 类型形参
  • 非类型形参

我们现在想要实现一个静态的栈，我们之前可以控制它存储数据的类型，但是现在我们想要控制它的大小，我们就可以用非类型模板参数。直接传入我们想要的存储大小的栈即可。

//#define N 100
// 想要实现一个静态的栈
// 用非类型模板参数(是一个常量)替代宏
template<class T,size_t N=10>
class myStack
{
public:
	void push(const T& x);
private:
	T _a[N];
	size_t _top;
};
int main()
{
	myStack<int,100> st1;//大小为100的栈
	myStack<int,200> st2;//大小为200的栈
	return 0;
}

 类型形参：出现在模板参数列表中，跟在class或者typename关键字之后的参数类型名称
 非类型形参：用整型常量作为类(函数)模板的一个参数，在类(函数)模板中可以将该参数当做常量来使用
注意：浮点数、类对象、字符串是不允许作为非类模板参数的
非类模板参数必须在编译期间就能确认结果
非类型模板参数是一个整型常量

二、模板的特化

2.1模板特化的概念

函数模板——可以理解为参数匹配
通常，使用模板可以实现一些与类型无关的代码，但是对于一些特殊类型的可能会得到一些错误的结果：

class Date
{
public:
	Date(int year,int month,int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
template<class T>
bool ObjLess(const T& left, const T& right) 
{
	return left < right;
}
int main()
{
	cout << ObjLess(1, 2) << endl;

	Date* p1 = new Date(2022, 1, 1);
	Date* p2 = new Date(2022, 2, 1);
	cout << ObjLess(p1, p2) << endl;
	return 0;
}

p1和p2交换一下声明顺序，得出来的结果可能不一样，这是因为new的原因，new是去堆上随机申请一块空闲的空间，我们传值初始化时，T被实例化为Date*类型，比较的就是两个指针的大小，所以出问题了。
解决：
函数模板——参数匹配
我们手动写一个最匹配的函数参数的版本

// 函数模板——参数匹配
template<class T>
bool ObjLess(const T& left, const T& right) 
{
	return left < right;
}

bool ObjLess(Date*& left,  Date*& right)
{
	return *left < *right;
}
int main()
{
	cout << ObjLess(1, 2) << endl;  //->匹配第一个模板
	Date* p1 = new Date(2022, 1, 1);
	Date* p2 = new Date(2022, 2, 1);
	cout << ObjLess(p1, p2) << endl;//->匹配第二个显示实例化类型
	return 0;
}

2.2函数模板特化

函数模板特化步骤：

  1. 必须要先有一个基础的函数模板
  2. 关键字template后面接一对空的尖括号<>
  3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
  4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

我们这里需要特化一下，即对于特殊的类型进行处理一下：
写法一：显示实例化

template<class T>
bool ObjLess(const T& left, const T& right) 
{
	return left < right;
}

写法二：特化(专用化)

template<>// 空的尖括号
bool ObjLess<Date*&>( Date*& left,  Date*& right)
{
	return *left < *right;
}

注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出，函数模板中，这种特化很鸡肋。

2.3类模板的特化

特化顾名思义就是特殊化，比如需要针对某些类型特殊化处理

特化步骤：

  1. 必须要先有一个基础的类模板
  2. 关键字template后面接一对空的尖括号<>
  3. 类名后跟一对尖括号，尖括号中指定需要特化的类型
2.3.1全特化

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

//普通模板
template<class T1, class T2>
class Data
{
public:
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};
//全特化模板
template<>
class Data<int, char> //注意这里给出了类型
{
public:
	Data() { cout << "Data<int, char>" << endl; }
private:
	int _d1;
	char _d2;
};
void Test()
{
	Data<int, int> d1;//调用第一个普通模板
	Data<int, char> d2;//调用第二个全特化模板
}
2.3.2偏特化

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。比如对于以下模板类

template<class T1, class T2>
class Data
{
public:
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

偏特化有以下两种表现方式：
第一种：部分特化

// 将第二个参数特化为int
template <class T1>
class Data<T1, int> {
public:
 Data() {cout<<"Data<T1, int>" <<endl;}
private:
 T1 _d1;
 int _d2;
};

第二种：参数更进一步的限制
偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

//两个参数偏特化为指针类型
template <class T1, class T2>
class Data <T1*, T2*>
{ 
public:
 Data() {cout<<"Data<T1*, T2*>" <<endl;}
private:
 T1 _d1;
 T2 _d2;
};
//两个参数偏特化为引用类型
template <class T1, class T2>
class Data <T1&, T2&>
{
public:
 Data(const T1& d1, const T2& d2): _d1(d1), _d2(d2)
 {
 cout<<"Data<T1&, T2&>" <<endl;
 }
private:
 const T1 & _d1;
 const T2 & _d2; 
 };
void test2 () 
{
 Data<double , int> d1; // 调用特化的int版本
 Data<int , double> d2; // 调用基础的模板 
 Data<int *, int*> d3; // 调用特化的指针版本
 Data<int&, int&> d4(1, 2); // 调用特化的指针版本
}

2.4非类型模板参数也是可以特化的

template<size_t N>
class A
{
public:
	A() { cout << "A<N>" << endl; }
};
template<>
class A<10>
{
public:
	A() { cout << "A<10>" << endl; }
};
void test()
{
	A<20> aa1;
	A<10> aa2;
}

三、模板的分离编译

3.1分离编译的概念

.h：函数声明和结构定义
.cpp：函数定义
平时的项目中，应该做到声明和定义分离，不然难以维护项目
一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。
模板是不支持分离编译

3.2模板的分离编译


// func.h
#include<iostream>
using namespace std;

void func1(int x);

template<class T>
void func2(const T& x);
/
// func.cpp
#include"func.h"
void func1(int x)
{
	cout << "void func1(x)" << endl;
}

template<class T >
void func2(const T& x)
{
	cout << "void func2(const T& x)" << endl;
}
//
// test.cpp
#include"func.h"
int main()
{
	func1(10);
	func2(20);
	return 0;
}

在这里插入图片描述
这是什么原因呢？
func.h func.cpp test.cpp

  1. 预处理——头文件展开/条件编译/宏替换/去掉注释…
    生成：vector.i test.i
  2. 编译——检查语法问题，没有问题，就生成汇编代码
    生成：vector.s test.s
  3. 汇编——把汇编代码转成二进制机器码
    生成：vector.o test.o
  4. 链接——把所有的.o文件链接起来形成obj文件

原因就是：模板T不知道具体类型，在编译时不处理，没有实例化，没有生成汇编代码，而正常的函数是可以找到汇编地址，并在链接时调用.
在这里插入图片描述

3.3解决办法

  1. 将声明和定义放到一个文件 xxx.hpp 或者xxx.h。推荐使用这种。
// func.h
#include<iostream>
using namespace std;

void func1(int x);

// 声明
template<class T>
void func2(const T& x);
// 定义
template<class T >
void func2(const T& x)
{
	cout << "void func2(const T& x)" << endl;
}

那么使用它的地方，头文件展开以后，直接就有模板定义和实例化,那么直接就可以填上函数调用地址。不需要链接去找。
这样普通函数是链接时去其他文件找，而模板函数是编译时就确定了地址。
由于声明和定义放在一起，维护性就会变得较差。

  1. 模板定义的位置显式实例化。这种方法不实用，不推荐使用。
// 显示实例化
// func.cpp
#include"func.h"
void func1(int x)
{
	cout << "void func1(x)" << endl;
}
template<class T >
void func2(const T& x)
{
	cout << "void func2(const T& x)" << endl;
}
// 解决办法显示实例化
template
void func2<int>(const int& x);

显示实例化的弊端就是：用一个就得实例化一个，需要使用的类型一多起来，就显得很麻烦！

总结模板

优点

  • 模板复用了代码，节省资源，更快的迭代开发。C++的STL因此而产生
  • 增强了代码的灵活性

缺点

  • 模板会导致代码膨胀问题，也会导致编译时间变长
  • 出现模板编译错误时，错误信息非常凌乱，不容易定位错误
Hero 2021
关注
专栏目录
【C++】 模板的分离编译
进阶之路
02-09 462
模板的进阶 非类型模板参数 类模板的特化 类模板特化的应用 模板的分离编译 非类型模板参数 模板参数分为类型模板参数与非类型模板参数。 类型形参：出现在模板参数列表中，跟在class或者typename后面的参数类型名称。 非类型形参，就是一个常量作为类（函数）模板的一个参数，在类（函数）模板中可将该参数当成常量来使用。 让我们来结合代码比较一下非类型模板参数的韵味. 我们先来...
【C++升级之路】第十二篇：模板进阶 | 非类型模板参数 & 模板特化 & 类模板的分离编译 & 模板优缺点总结
Captain_ldx的博客
04-10 896
非类型模板参数，函数模板特化，类模板特化（全特化，部分特化，参数更进一步的限制），类模板的分离编译问题，模板优缺点总结
模板与泛型编程
qq_43205670的博客
08-16 293
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。 函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。 模板的格式 template<typename T1, typename T2,…,typename Tn> 返回值类型 函数名(参数列表){} 模板分为类模板和函数模板 模板它本身并不是函数，是编译...
C++：模板分离编译
AngelDg的博客
04-11 466
什么是分离编译 一个程序(项目)由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。 模板的分离编译 假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义: // a.h template<class T> T Add(const T& left, const T& ri...
C++模板之分离编译
晶凌玄夜的博客
01-14 286
1 什么是分离编译 一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。 2 模板的分离编译 假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义： head.h template <class T> T Add(const T& left, const T&am...
C++ —— 类模板的分离式编译
weixin_30558305的博客
03-08 135
目录 对于C++中类模板的分离式编译的认识 具体的实例 1、对于C++中类模板的分离式编译的认识 为什么C++编译器不能支持对模板的分离式编译（博文链接） 主要内容：编译器编译的一般工作原理、对模版的分离式编译的特殊性（模版的特殊性） 链接：　　http://blog.csdn.net/pongba/article/details/19130 模...
掌握C/C++实现的初阶与高阶数据结构
对于高阶数据结构，C++的优势更加明显，因为它支持模板和异常处理等特性，使得实现如二叉树、平衡树（AVL树）、B树、图等数据结构更为方便。例如： - 二叉树通常使用递归方法来实现各种遍历（前序、中序、后序）。 ...
C++之模板进阶
be_a_struggler的博客
11-09 578
C++模板，非类型模板参数，函数模板的特化，类模板的特化，模板分离编译，模板总结
C++笔记 模板的进阶知识
qq_64105689的博客
02-19 608
一个程序（项目） 由若干个源文件共同实现，通过编译形成目标文件，最后将目标文件链接形成单一的可执行文件，执行的过程就叫做分离编译。1.模板复用了代码，增加了开发效率，C++的模板库(STL)也因此而诞生2.增强了代码的灵活性1.模板会导致代码膨胀的问题，编译时间变长2.模板编译错误时，错误信息非常凌乱，不易定位错误t=N176。
C++——类和对象初阶讲解完整版（类的引入、类的定义、类的作用域、类的实例化、类访问限定符及封装、类成员函数的this指针、析构函数、构造函数、拷贝构造函数、赋值操作符重载、类的静态成员......）
weixin_53811859的博客
12-01 1831
家人们，百闻不如一见，百见不如一品啊！三万字超详细的C++类和对象讲解你值得拥有！
详解C++函数模板与分离编译模式
08-18
主要介绍了详解C++函数模板与分离编译模式的相关资料，帮助大家更好的理解和学习c++，感兴趣的朋友可以了解下
【C++】关于C++模板的分离编译问题
weixin_63449996的博客
03-09 1669
探讨C++模板的分离编译问题。
C++模板的分离编译
littledarlings的博客
11-21 358
分析为什么模板不支持分离编译？
C++ - 模板分离编译
chihiro1122的博客
08-04 1179
所以，现在你应该明白这个问题出来哪一个身上了，没错就是 编译器的问题。问题就出在编译的时候，因为地址是存在编译生成的 .s 文件当中，而在声明当中给的模版参数是 T，编译器在编译的时候不知道 这个 T 是什么类型，没错，就是出在了没有实例化上面。编译器都不知道实例化出的 T 的类型是什么，就无法生成这个函数的地址。func1（）可以生成地址是因为 func1（）不是模版函数，而push（）是模版参数，只有实例化之后才能生成地址。
C++模板与分离编译
mac_timmy
02-24 348
个人博客传送门 分离编译模式 一个项目如果有多个源文件组成，每个源文件单独编译，形成目标文件。最后通过链接器将所有的目标文件链接起来，形成一个可执行的文件。这个过程就叫做分离编译。 模板不能分离编译 有一个项目，其中函数声明放在”test.h”中，函数实现放在”test.cpp”中，函数调用放在”main.cpp”中。如果没用使用模板，将不会有任何问题。而且这样是被推荐使用的。但是如果...
关于C++模板分离式编译
wk_bjut_edu_cn的博客
12-16 606
以前一直没注意这个问题，下面进行总结 分离编译模式 一个项目如果有多个源文件组成，每个源文件单独编译，形成目标文件。最后通过链接器将所有的目标文件链接起来，形成一个可执行的文件。这个过程就叫做分离编译。 分离式编译的优势 如果工程巨大（比如linux内核源码） ， 当你只修改了其中一个文件的时候，只要编译改动过的就可以了，不需要全部重新编译。 模板不能分离编译 有一个项目，其中函数声明...
C++模板的分离编译问题
最新发布
weixin_57761086的博客
08-15 387
介绍了编译的大致流程，以及为什么模板的声明和定义不应该分开。
模板为什么不支持分离编译?
阿亮的博客
12-05 617
模板为什么不支持分离编译? 首先，一个编译单元（translation unit）是指一个.cpp文件以及它所#include的所有.h文件，.h文件里的代码将会被扩展到包含它的.cpp文件里，然后编译器编译该.cpp文件为一个.obj文件（假定我们的平台是win32），后者拥有PE（Portable Executable，即windows可执行文件）文件格式，并且本身包含的就已经是
C++————模板的分离编译
陶超的博客
09-08 414
模板的分离编译1.模板的分离编译=模板+分离编译2.对于模板我们并不陌生，但什么是分离编译呢？，分离编译即就是：一个程序有若干个源文件（.cpp文件）共同实现，而每个源文件单独生成目标文件（.obj文件），最后将所有目标文件链接起来形成单个可执行文件（.exe）。那么模板的分离编译到底是什么？模板的分离编译即就是模板的类的成员方法写在.cpp文件中和模板类写在.h文件中区别开来。然而模板的分离编译会
CC++进阶指南：内存管理与底层操作详解
"CC++晋级经典资料是一份详尽的C++进阶学习指南，它涵盖了C++语言的核心概念以及底层内存管理的关键技术。该资料从内存模型、栈与堆、全局内存、内存管理器、共享内存和线程局部存储等基础知识出发，深入剖析了内存...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值