【 C++ 】模板初阶

目录

​编辑

一、泛型编程

二、函数模板

1.概念

2.格式

3.原理

4.匹配原则

三、类模板

1.定义格式

2.类模板的实例化

---

一、泛型编程

泛型编程是一种编程范式，它允许在编写代码时使用一种通用的数据类型或算法，以便在不同的数据类型上进行操作，而不需要为每种数据类型编写专门的代码。泛型编程的目标是提高代码的重用性和可扩展性。

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

当我们想对不同的类型实现交换函数，我们以前的做法是写多个重载函数：

int Swap(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}

void Swap(double& a, double& b)
{
	double temp = a;
	a = b;
	b = temp;
}

使用函数重载虽然可以实现，但是有一下几个不好的地方：

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

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

当我写代码时就想着，要是编译器能够自动识别出类型套用到函数里去就好了。

但是现在，实现了！！！

有请出我们的模板：

---

二、函数模板

1.概念

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

函数的特定类型版本。

2.格式

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

返回值类型 函数名(参数列表){}

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

class)

现在我们有了模板，如何将swap函数变成模板呢：

template<typename T>
void Swap(T a, T b)
{
	T temp = a;
	a = b;
	b = temp;
}

3.原理

模板本身不能调用，模板是生成具体的函数

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。

所以其实模板就是将本来应该我们做的重复的事情交给了编译器

在编译器编译的时候，编译器会根据实参传给形参来推断对应的类型，再用对应的类型来生成函数。

template<typename T>
void Swap(T a, T b)
{
	T temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 1, b = 2;
	double da = 1.3, db = 1.6;
	Swap(a, b);
	Swap(da, db);
	return 0;
}

所以在这里，a、b和da、db它们所调用的函数不是同一个函数。而是编译器根据推导的类型会生成相应的类型函数。

那如果我们将俩个不同类型的传入Swap模板呢？

可以看到编译器报错了。

但如果我们就想传不同类型应该怎么办呢？

用函数模版生成对应的函数 -> 模版的实例化

方法1：推导实例化

template<typename T>
void Swap(T a, T b)
{
	T temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 1, b = 2;
	double da = 1.3, db = 1.6;
	Swap(a, b);
	Swap(da, db);

	//1.推导实例化
	Swap(a, (int)da);
	Swap((double)b, db);
	return 0;
}

方法2：显示实例化

template<typename T>
void Swap(T a, T b)
{
	T temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 1, b = 2;
	double da = 1.3, db = 1.6;
	//隐式实例化:让编译器根据实参推演模板参数的实际类型
	Swap(a, b);
	Swap(da, db);

	//1.推导实例化
	Swap(a, (int)da);
	Swap((double)b, db);

	//2.显示实例化:在函数名后的<>中指定模板参数的实际类型
	Swap<int>(a, da);
	return 0;
}

在显示实例化中，如果类型不匹配，编译器会进行隐式类型转换。如果无法转换，则编译器会进行报错。在上面的例子中，编译器就对da进行了隐式类型转换，转换成int类型的数据。

方法3：

当你就是不想进行任何的转换，那么这时你还可以对模板进行修改，修改成多参数模板：

template<typename T1,typename T2>
void Swap(T1 a, T2 b)
{
	T1 temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 1;
	double da = 1.1;
	Swap(1, 1.1);
	return 0;
}

---

注：当类型T没有在函数的形参中出现时，必须进行显示实例化：

template<class T>
T* func(int n)
{
	return new T[n];
}

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

这是因为，编译器无法通过实参传给的形参来判断类型，所以必须明确指出类型给编译器。

---

4.匹配原则

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

个非模板函数

2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而

不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模

板

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

template<class T>
void Swap(T a, T b)//1
{
	T temp = a;
	a = b;
	b = temp;
}

void Swap(int a, int b)//2
{
	int temp = a;
	a = b;
	b = temp;
}

template<class T1,class T2>
void Swap(T1 a, T2 b)//3
{
	T1 temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 1, b = 2;
	double da = 1.1, db = 2.2;

	Swap(a, b);//与非模板函数匹配，走第二个

	Swap<int>(a, b);//指明要用模板，走第一个

	Swap(da, db);//比起非模板函数，T1、T2模板更加匹配，走第三个

	return 0;

}

---

三、类模板

1.定义格式

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

用栈举一个类模板的例子：

template<typename T>
class Stack
{
public:
	Stack(int n=4)
		:_arr(new T[n])
		,_capacity(0)
		,_size(0)
	{

	}

	void Push(const T& data)
	{
		if (_size == _capacity)//当栈已经满了的时候
		{
			T temp = new T[_capacity * 2];
			memcpy(temp, _arr, sizeof(T) * _size);//这一步类似于以前的realloc
			delete[]_arr;
			_arr = temp;
			_capacity *= 2;
		}
		_arr[_size++] = data;
	}
private:
	T* _arr;
	int _capacity;
	int _size;
};

int main()
{
	Stack<int>s1;
	s1.Push(1);
	s1.Push(2);

	Stack<double>s2;
	s2.Push(1.1);
	s2.Push(2.2);
	return 0;
}

一个模板对应一个类或者函数，所以当我们想将类里面的函数放在类外面来进行使用，那必须重新为这个函数写一个模板，如下：

template<typename T>
class Stack
{
public:
	Stack(int n = 4)
		:_arr(new T[n])
		, _capacity(0)
		, _size(0)
	{

	}

	void Push(const T& data);
private:
	T* _arr;
	int _capacity;
	int _size;
};

template<class T>
void Stack<T>::Push(const T& data)
{
	if (_size == _capacity)//当栈已经满了的时候
	{
		T temp = new T[_capacity * 2];
		memcpy(temp, _arr, sizeof(T) * _size);//这一步类似于以前的realloc
		delete[]_arr;
		_arr = temp;
		_capacity *= 2;
	}
	_arr[_size++] = data;
}

int main()
{
	Stack<int>s1;
	s1.Push(1);
	s1.Push(2);

	Stack<double>s2;
	s2.Push(1.1);
	s2.Push(2.2);
	return 0;
}

注意：模板不建议将声明和定义分离到两个文件

---

2.类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的

类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

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

---

---

---

如果这篇文章有帮助到你，请留下您珍贵的点赞、收藏+评论，这对于我将是莫大的鼓励！学海无涯，共勉！😘😊😗💕💕😗😊😘

---

---

---