【C++】模板初阶

🫧个人主页：小年糕是糕手

💫个人专栏：《C++》《C++同步练习》《数据结构》《C语言》

🎨你不能左右天气，但你可以改变心情；你不能改变过去，但你可以决定未来！

---

---

目录

一、泛型编程

二、函数模板

2.1、函数模板概念

2.2、函数模板格式

2.3、函数模板的原理

2.4、函数模板的实例化

（一）隐式实例化

（二）显示实例化

2.5、模板参数的匹配原则

三、类模板

3.1、类模板的定义格式

3.2、类模板的实例化

3.3、类模板中的缺省参数

---

一、泛型编程

首先我们来回想一下我们之前写过的交换函数：

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

我们发现一个类型就有一个对应的交换函数，这样写起来是十分麻烦的，同时使用函数重载虽然可以实现，但是有一下几个不好的地方：

1、重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数

2、代码的可维护性比较低，一个出错可能所有的重载均出错

那我们想想有没有通用的交换函数呢？ 能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

有的兄弟有的，这就是我们这篇博客要讲的 -- 模板初阶

如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件(即生成具体类型的代码），那将会节省许多头发！巧的是前人早已将树栽好，我们只需在此乘凉：

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

二、函数模板

2.1、函数模板概念

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

2.2、函数模板格式

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

template<typename T>
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

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

// 函数模板
#include<iostream>
using namespace std;
template<typename T>
void Swap(T& x, T& y)
{
    T tmp = x;
    x = y;
    y = tmp;
}

int main()
{
    int i = 1, j = 2;
    Swap(i, j);
    char c1 = 'z', c2 = 'y';
    Swap(c1, c2);
    cout << i << j << endl;
    cout << c1 << c2 << endl;
    return 0;
}
//交换必须是同类型的
//他们调用的实际上是函数模板推演出来的不同类型的函数

2.3、函数模板的原理

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

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。
比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

2.4、函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。
模板参数实例化分为：隐式实例化和显式实例化。

#include<iostream>
using namespace std;
template<class T>
//模板是泛型的,我们不知道T是什么类型
//不可以写成T Add(T left, T right);
//用引用如果我们不需要去改变就要加上const
T Add(const T& left, const T& right)
{
    return left + right;
}

int main()
{
    int a = 10, b = 20;
    double c = 1.1, d = 1.2;
    cout << Add(a, b) << endl;
    cout << Add(c, d) << endl;

    return 0;
}

（一）隐式实例化

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

//函数模板的实例化
#include<iostream>
using namespace std;
template<class T>
//模板是泛型的,我们不知道T是什么类型
//不可以写成T Add(T left, T right);
//用引用如果我们不需要去改变就要加上const
T Add(const T& left, const T& right)
{
    return left + right;
}

int main()
{
    int a = 10, b = 20;
    double c = 1.1, d = 1.2;

    //隐式实例化:函数模板的参数是由实参传递给形参,自己推导,但是推导过程中不能发生矛盾
    cout << Add(a, b) << endl;
    cout << Add(c, d) << endl;

    //这里的类型必须是匹配的,不可以一个int,一个double
    //error，这里有俩种解决方案
    cout << Add(a, c) << endl;
    //plan 1:强制类型转换
    cout << Add((double)a, c) << endl;
    //plan 2:显示实例化:在函数名和实参的列表中间加入<>进行实例化
    cout << Add<int>(a, c) << endl;
    cout << Add<double>(a, c) << endl;
    
    return 0;
}

（二）显示实例化

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

//显式实例化的应用
#include<iostream>
using namespace std;

template<class T>
//这个模板中没有使用T来定义形参
void func(size_t n)
{
	T* ptr = new T[];
	cout << ptr << endl;
	//...
}

int main()
{
	//没有与参数列表匹配的函数模板 "func" 实例
	func(10);

	//显式实例化:通过实参类型来推导模板参数
	func<int>(10);

	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版本
}

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

//参数匹配
#include<iostream>
using namespace std;
//专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}

//通用加法函数
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}

int main()
{
	//上述的俩种可以同时存在他们构成函数重载
	//会优先调用int,有现成的先用现成的,没有再去调用模板
	int a = 10, b = 20;
	double c = 1.1, d = 1.2;

	cout << Add(a, b) << endl; 
	cout << Add(c, d) << endl; 
}

#include<iostream>
using namespace std;
//专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}

//通用加法函数
template<class T>
T Add(const T& left, const T& right)
{
	return (left + right) * 10;
}

int main()
{
	//上述的俩种可以同时存在他们构成函数重载
	//会优先调用int,有现成的先用现成的,没有再去调用模板
	int a = 10, b = 20;
	double c = 1.1, d = 1.2;

	cout << Add(a, b) << endl; // 与非函数模板类型完全匹配，不需要函数模板实例化
	cout << Add(c, d) << endl;

	//假设我们就是强行只想调用模板
	cout << Add<int>(a, b) << endl; //模板函数可以生成更加匹配的版本
                                    //编译器根据实参生成更加匹配的Add函数
}

这里我们也可以尝试多一个模板参数来实现真正的通用：

#include<iostream>
using namespace std;
//专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}

//通用加法函数
template<class T1, class T2>
T2 Add(const T1& left, const T2& right)
{
	return (left + right) * 10;
}

int main()
{
	//上述的俩种可以同时存在他们构成函数重载
	//会优先调用int,有现成的先用现成的,没有再去调用模板
	int a = 10, b = 20;
	double c = 1.1, d = 1.2;
     
    cout << Add(1, 2) << endl;
    cout << Add(1, 1.2) << endl;
}

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

#include <iostream>
using namespace std;

// 模板函数：严格类型匹配，不自动转换
template <typename T>
T Func(T a, T b) {
    return a + b;
}

// 普通函数：支持自动类型转换
int CommonFunc(int a, int b) {
    return a + b;
}

int main() {
    int a = 5;
    double b = 3.2; // 不同类型的参数

    // 1. 模板函数：直接调用报错（int和double类型不匹配，不自动转换）
    // cout << Func(a, b) << endl; 

    // 模板函数：手动转类型后才能调用（显式让类型一致）
    cout << "模板函数（手动转类型）：" << Func((double)a, b) << endl;

    // 2. 普通函数：自动转换（double→int，3.2截断为3）
    cout << "普通函数（自动转类型）：" << CommonFunc(a, b) << endl;

    return 0;
}

输出结果：

模板函数（手动转类型）：8.2
普通函数（自动转类型）：8

核心结论：

• 模板函数：必须保证参数类型完全一致 ，编译器不会自动做int→double这类转换；
• 普通函数：编译器会自动把double转成int，匹配函数参数类型。

三、类模板

3.1、类模板的定义格式

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

//类模板
#include<iostream>
using namespace std;
template<class T>
class Stack
{
public:
	Stack(size_t n = 4)
		:_a(new T[n])
		,_top(0)
		,_capacity(n)
	{ }

	void Push(const T& x)
	{
		//扩容
		//...
		_a[_top++] = x;
	}

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


int main()
{
	//显式实例化
	Stack<int> st1;   //存int
	Stack<double> st2;//存double
	st1.Push(1);
	st2.Push(1.1);

	return 0;
}

模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误，具体原因后面会讲

//泛型编程
//模板不支持声明和定义分离定义.h 和 .cpp
//如果非要声明和定义分离需要进行以下的操作:
#include<iostream>
using namespace std;
template<class T>
class Stack
{
public:
	// 1. 类内声明构造函数，并加上默认参数
	Stack(size_t n = 4);
	// 2. 类内声明Push成员函数
	void Push(const T& x);
private:
	T* _a;
	size_t _top;
	size_t _capacity;
};

template<class T>
Stack<T>::Stack(size_t n)
	:_a(new T[n])
	, _top(0)
	, _capacity(n)
{
}

template<class T>
void Stack<T>::Push(const T& x)
{
	//扩容
	//...
	_a[_top++] = x;
}

int main()
{
	//显式实例化
	Stack<int> st1;   //存int
	Stack<double> st2;//存double
	st1.Push(1);
	st2.Push(1.1);

	return 0;
}

3.2、类模板的实例化

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

// Stack是类名，Stack<int>才是类型
Stack<int> st1;    // int
Stack<double> st2; // double

3.3、类模板中的缺省参数

//缺省参数
#include<iostream>
using namespace std;
//这里的缺省参数默认是个类型
template<class T = int>
class A
{
public:
	T x1;
	T x2;
};

//多个缺省参数缺省必须从右往左
//传时是从左往右
template<class T1, class T2 = int>
class B
{
public:
	T1 x3;
	T2 x4;
};

int main()
{
	A<> aa1;//不传默认就是int
	A<int> aa2;
	A<double> aa3;

	//俩者等价
	B<double> bb1;
	B<double, int> bb2;

	return 0;
}

类模板中的类型模板参数的缺省参数给的是类型！

---