c++模板

饼干烧饼

已于 2024-08-10 18:40:57 修改

阅读量424

点赞数 13

分类专栏： C++ STL 文章标签： c++ 开发语言

于 2024-08-10 18:39:15 首次发布

本文链接：https://blog.csdn.net/cookies_s_/article/details/141086798

版权

C++ 同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

STL

4 篇文章 0 订阅

订阅专栏

1.泛型编程

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段，模板是泛型编程的基础。

例如实现通用的A+B，面对不同的类型可以使用函数重载，但重载的函数仅仅参数类型不同，内部实现相同，这样会使代码复用率较低，而且可维护性也较低。可以使用模板，让编译器根据不同的类型利用模板来实例化相应的函数。

//int Add(int a, int b)
//{
//	return a + b;
//}
//long Add(long a, long b)
//{
//	return a + b;
//}
//double Add(double a, double b)
//{
//	return a + b;
//}
//long long Add(long long a, long long b)
//{
//	return a + b;
//}
........

//使用模板一步到位
template <class T>
T Add(T a, T b)
{
	return a + b;
}

int main()
{
	int a = 2, b = 8;
	double a1 = 5.34, b1 = 48.333;
	cout << Add(a, b) << endl;//10
	cout << Add(a1, b1) << endl;//53.673
	cout << Add<int>(a, b1) << endl;//50
	cout << Add<double>(a, b1) << endl;//50.333

	return 0;
}

模板可以分为 函数模板 和 类模板

2.函数模板

2.1概念

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

2.2格式

template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(T1 a, T2 b)
{
    Tn c = 1;
    //......
}

typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

2.3原理

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。

2.4函数模板的实例化

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

template <class T>
T add(T a, T b)
{
	return a + b;
}

int main()
{
	int a = 2, b = 8;
	double a1 = 5.34, b1 = 48.333;
	cout << add(a, b) << endl;//隐式实例化成int
	cout << add(a1, b1) << endl;//隐式实例化成double
	//cout << add(a, b1) << endl;//这里直接传int和double类型进行隐式实例化会报错，因为模板参数只有一个T，编译器不知道要推演成哪个类型
	//解决办法有：1.重新设计一个模板，如template<class T1, class T2>
	//					   2.对实参进行强转，使两个实参类型相同
	//                   3.使用显式实例化，指定T的类型
	return 0;
}

2.显式实例化：在调用时函数名后的<>中指定模板参数的实际类型

template <class T>
T add(T a, T b)
{
	return a + b;
}

int main()
{
	int a = 2, b = 8;
	double a1 = 5.34, b1 = 48.333;
	cout << add<int>(a, b1) << endl;//指定int类型
	cout << add<double>(a, b1) << endl;//指定double类型
	
	return 0;
}

指定模板类型时如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

需要显式实例化的场景：

模板也是可以给缺省类型的：

2.5函数模板的匹配原则

一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数，当调用时与非模板函数匹配，优先调用非模板函数，如果模板可以产生一个具有更好匹配的函数，那么将选择模板。（模板函数不允许自动类型转换，但普通函数可以进行自动类型转换）

3.类模板

3.1格式

template<class T1, class T2, ...... ,class T3>
class 类模板名
{
	//.......
};

3.2 实例化

template <class T>
class A
{
public:
	A(size_t n = 0)
		:_size(n)
	{
		_arr = new T[n];
	}
	~A()
	{
		if (_arr)
		{
			delete[] _arr;
			_arr = nullptr;
			_size = 0;
		}
	}
	T* _arr;
	size_t _size;
};

int main()
{
	A<int> arr(10);
	A<char> s(5);
	cout << typeid(arr._arr).name() << endl;
	cout << typeid(s._arr).name() << endl;

	return 0;
}

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类，根据不同类型实例化出来的类，类的类型不同，属于不同的类。

4.非类型模板参数

模板参数分为类型形参与非类型形参。
类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用（既然是常量那就不能修改），非类型形参可以给缺省值

注意：
1.非类型模板参数给的值不同，实例化出来的类也是属于不同的类（st1和st2的类型不同）
2.c++20之前非类型模板参数只能是整型参数（规定），c++20之后就支持double等其他内置类型
3.非类型模板常数可以给缺省值

5.使用非类型模板参数的array

array是固定大小（静态数组）的数组（用了非类型模板参数）

array<int,10>与int[10]的主要区别：越界检查，c语言对越界检查是一种抽查机制(越界读一般检查不出来)，只能检查越界写入，检查位置一般是设置的标志位，标志位之外的越界也没办法检查。
array作为自定义类型，可以对越界访问和写入进行严格的检查。

array的空间不是开在堆区的，是在栈帧开的，栈帧本身不大（一般8M），开太大容易栈溢出；
vector的空间是开在堆区的，堆区较大，需要大量空间时要在堆上开。

6.模板的特化

6.1 概念

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板

Less(pa3, pb3); 比较的并非指针指向的字符串，而是直接比较地址的大小。
此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

6.2函数模板特化

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

一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出（即普通函数），普通函数实现简单明了，代码的可读性高。

6.3 类模板特化

6.3.1全特化

全特化即是将模板参数列表中所有的参数都确定化
普通函数与特化同时存在优先调用普通函数

6.3.2偏特化

偏特化有以下两种表现方式：
部分特化：将模板参数类表中的一部分参数特化
参数限制：偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本，例如类型限定为指针、引用或者多种组合限定

部分特化：

参数限定（限定为指针或引用）：

从上面的执行结果可知，参数限定为<T1*, T2*>,传入<int*, char*>，T1并非是int*,而是int，T2并非是char*，而是char，参数限定为引用也同理。这样做是为了方便传进来的类型既可以定义原类型，又可以定义指针或引用类型（例如限定为<T*>传入int*，T是int，T既可以定义T类型，又可以定义T*或T&类型）。

7.typename

typename不仅是定义模板参数的关键字，还可以告知编译器调用的是类型而不是其他变量，当你使用一个嵌套的类型(例如，模板类的成员类型)时，编译器可能无法确定该类型是类型还是变量。在这种情况下，你需要使用typename 来告诉编译器它是一个类型。这通常在模板类的成员或者嵌套的类型时出现。

类名:: 的访问方式一般是去访问静态成员变量、静态成员函数、typedef的类型和内部类， 编译器编译模板时，编译器并不会将模板进行实例化再检查，最多对模板的外壳进行检查，不会对内部进行详细检查， vector<T>::const_iterator时，vector<T>这个类并没有实例化，vector<T>::可以访问typedef的变量和静态成员函数和内部类，但vector<T>没有实例化不能进行详细检查，vector<T>::const_iterator时编译器不知道访问的是哪一种，所以使用typename，告知编译器vector<T>::const_iterator是类型，等vector<T>实例化后再去检查。