C++|模板初阶

目录

一、泛型编程

二、函数模板

2.1函数模板概念

 2.2函数模板原理

2.3函数模板的实例化 

2.4模板参数的匹配原则

三、类模板

3.1类模板定义格式 

3.2类模板实例化

---

一、泛型编程

泛型编程：与类型无关的通用代码，是代码复用的一种手段。可以理解为有一组通用的代码（模板）可以适应各种类型，而不局限于一种类型。模板分为函数模板和类模板。

引入：

#include <iostream>
using namespace std;


void swap(int& left, int& right)
{
	int tmp = right;
	right = left;
	left = tmp;
}
 
void swap(double& left, double& right)
{
	double tmp = right;
	right = left;
	left = tmp;
}

int main()
{
	int a = 2, b = 3;
	double c = 1.2, d = 2.3;
	swap(a, b);
	swap(c, d);
	cout << a << " " << b << endl;
	cout << c << " " << d << endl;
	return 0;
}

分析：

1.实现不同类型交换函数，可以通过重载函数来达到目的，但是写重载函数就增加了代码量，复用率低。 

2.这样就导致了代码的可维护性比较低，一个出错可能所有的重载均出错。

面对上述情况，接下来就可以引入一组通用代码（函数模板）来实现。 

二、函数模板

2.1函数模板概念

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

函数模板格式：

template<typename T1,typename T2,....,typename Tn>    注意：T的名字随便取

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

---

 举例：

#include <iostream>

using namespace std;
template<typename P>

void Swap(P &left, P &right)
{
	P tmp = right;
	right = left;
	left = tmp;

}
int main()
{
	int a = 2, b = 3;
	double c = 2.3, d = 3.2;


	Swap(a, b);
	Swap(c, d);
	cout << a << " " << b << endl;
	cout << c << " " << d << endl;
	return 0;
}

上面例子就是一个模板， 用P表示一个泛型的类型，能够识别各种类型，传int类型，P就能识别他是int类型，传double类型，P就能够识别他是double类型，这些都是由编译器去完成的，我们只需传递想要表达的类型给它就行了。

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

 2.2函数模板原理

用一张图来形象的表示函数模板的操作。 

 

编译器会在编译阶段对模板类型进行检测，根据传入的实参类型来推演生成对应类型的函数以供调用。当char类型使用函数模板时，编译器则对实参类型进行推演，将T确定为char类型，然后产生一份专门处理char类型的代码，当为其他类型时亦是如此。 

2.3函数模板的实例化 

 对于上述，用不同的类型的参数使用函数模板时，就称为函数模板的实例化。模板参数实例化又分为：隐式实例化和显示实例化

隐式实例化：让编译器根据实参类型自己去推演，而不是给模板指定类型。

#include <iostream>
using namespace std;

template<class T>
void Swap(T& left, T& right)
{
	T tmp = right;
	right = left;
	left = tmp;

}

template<class T>
T Sum(const T& left,const T& right)
{
	return left + right;
}
int main()
{
	int a = 2, b = 3;
	double c = 2.3, d = 3.2;


	Swap(a, b);
	Swap(c, d);
	cout << a << " " << b << endl;
	cout << c << " " << d << endl;

	int sum = Sum(a, b);
	cout << sum << endl;
	return 0;
}

 

上述就是一个 隐式类型实例化，一方面注意的是，模板中只有一个参数时，其推演的类型是一一对应的，而传不同类型就会报错，例如：还是上述代码，对于Sum函数，实参传a和c，a是int类型，而c是double类型，那么T就不能推演到底是int类型还是double类型。另一方面注意的是，一个函数模板对应一个函数，函数模板与函数模板之间是互不影响的，例如上述有两个函数模板，他们是互不干扰的，且不能用一个函数模板套用两个函数，这是会报错的。

如图：

 

那么为了解决上述问题，除了可以用强转，还可以使用显示实例化。

显示实例化：调用函数时在函数名后面接一个<>，在其中指定模板参数的实际类型。 

#include <iostream>
using namespace std;

template<class T>
T Sum(const T& left,const T& right)
{
	return left + right;
}
int main()
{
	int a = 2, b = 3;
	double c = 2.3, d = 3.2;

	int sum = Sum<int>(a, c);//给函数模板指定为int类型
	cout << sum << endl;
	return 0;
}

 

 上述给函数模板指定了int类型，那么T就会被推演为int类型，double类型的c也会隐式转换成int类型，对于不能隐式转换的编译器就会报错。

对于上述类型不匹配问题，还有一种方法就是再添加一个模板参数进行匹配，接下来对这一方法进行讲述

2.4模板参数的匹配原则

①.对于不是模板的普通函数可以和同名的模板函数同时存在，该模板函数可以实例化为该普通函数。

②.当普通函数和同名的模板函数同时存在，在调用函数时，实参类型既符合普通函数又符合模板函数，那么会优先调用普通函数，如果实参类型在模板函数中比在普通函数中更符合，那么会选择模板。

③.模板函数中，模板参数识别实参是啥类型那么模板参数就是啥类型，不会发生隐式转换。而普通函数的形参是定好的类型，实参类型可以发生隐式类型转换成形参类型。

例如：

#include <iostream>
using namespace std;


int Sum(int& left, int& right)//只能是int类型
{
	cout << "Sum(int& left, int& right)" << endl;
	return left + right;

}


template<class T, class Y>//使用多参数模板，T和Y可以是不同类型
T Sum(const T& left,const Y& right)
{
	cout << "Sum(const T& left,const Y& right)" << endl;;
	return left + right;
}
int main()
{
	int a = 2, b = 3;
	double c = 2.3, d = 3.2;

	int sum1 = Sum(a, b);//实参类型既符合普通函数又符合模板函数，会优先调用普通函数
	cout << sum1 << endl;

	int sum2 = Sum(a, c);//实参类型在模板函数中比在普通函数中更符合
    //在普通函数中c得隐式类型转换为int，在模板函数中可以直接推演各自类型进行匹配，不需要隐式转换
	cout << sum2 << endl;
	return 0;
}

运行结果： 

 

通过结果也可以看出，第一个优先调用了普通函数，第二个优先调用了模板函数 。

当然除了函数有模板，那么类同样也是有模板，现在来了解了解~

三、类模板

3.1类模板定义格式 

类模板概念与函数模板概念类似，其定义格式为：

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

class 类模板名

{

        ///类成员

};

3.2类模板实例化

 类模板实例化与函数模板实例化还是有区别的，类模板实例化就相当于是显示实例化了，需要在类模板名字后跟<>,将实例化类型放<>里面即可，同时，类模板的类型，就变成了实例化的类型了，即：类名<数据类型>

例如：stack<int> s;   vector<double> v;等

---

接下里对类模板的实例化进行演示以及为什么要有类模板，通过之前学过的栈来进行举例：

#include <iostream>
using namespace std;


template<class T>
class stack
{
public:
	stack()
	{
		_capacity = 0;
		_size = _capacity;
		_a = new T[_capacity];

	}

	~stack()
	{
		delete[] _a;
		_a = nullptr;
		_size = 0;
		_capacity = 0;
	}


	void push_back(const T x)
	{
		if (_size == _capacity)
		{
			int _newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			_capacity = _newcapacity;
			T* tmp = new T[_capacity];
			
			memcpy(tmp, _a, sizeof(T)*_size);
			delete[] _a;
			_a = tmp;
		}
		_a[_size] = x;
		_size++;
	}

	void print()
	{
		for (int i = 0; i < _size; i++)
		{
			cout << _a[i] << " ";
		}
		cout << endl;
	}


private:
	T* _a;
	int _size;
	int _capacity;
};
int main()
{
	stack<int> s;//类模板的实例化，数据类型为int
	s.push_back(1);
	s.push_back(2);
	s.push_back(3);
	s.push_back(4);
	s.push_back(5);
	s.print();

	stack<double> s1;//类模板的实例化，数据类型为double
	s1.push_back(1.1);
	s1.push_back(2.1);
	s1.push_back(3.1);
	s1.push_back(4.2);
	s1.push_back(5.5);
	s1.print();
	return 0;
}

运行结果： 

 

通过以上例子、结果，可以看出采用了类模板，那么模板参数T可以接收各种类型来进行推演，只需要实例化想要的数据类型就行了，而对于传统的类，只能确定为一种类型，当想要接收其他类型时，又得造一个轮子，降低效率，从而体现了类模板的优势。