泛型编程 ＜模板＞

泛型编程

重点：
1.熟悉模板的语法
2.模板的原理
3.理解 基础语法+类和对象+模板 去解决C语言不足的问题和意义
使用模板， 编写跟类型无关的代码
例如在一些函数和类的时候，针对不同类型需要写很多重复的代码（swap函数）
类：比如我们想实现一个数据结构栈stack，stack的多个对象，st1存int，st2存double，等等。
解决方案：
1.函数模板
template
void swap(T& a, T& b){…}
2.类模板
template
class stack
{
private:
T* _a;
size_t size;
size_t capacity;
}

模板的原理

编译器根据调用函数模板和类模板的类型，实例化出对应的函数和类
编译器是把实例化生成的函数和类放到进程的代码段去执行 (模板不是指令)

c语言和C++优缺点：
忘记初始化和销毁----> 构造函数和析构函数
没有封装，谁都可以修改结构体的数据----> 类 + 访问限定符
如果想同时定义两个栈，一个栈存int，一个栈存double，做不到---->模板

引用传参：1. 修改传递的实参比如swap 2.减少拷贝
引用传返回值：1.修改返回对象如operator[ ] 2.减少拷贝
代码如下：

#include <iostream>
#include <assert.h>
using namespace std;

//template<class T>
//class Stack_cpp
//{
//public:
//	Stack_cpp()
//	{}
//	~Stack_cpp()
//	{}
//	void Push(T x)
//	{}
//private:
//	T* _a;
//	int _size;
//	int _capacity;
//};

//template<class T>
//class SeqList{
//
//};

template<class T>
class vector//动态增长的数组
{
public:
	vector()
		:_a(nullptr)
		, _size(0)
		, _capacity(0)
	{}

	~vector(){
		delete[] _a;
		_a = nullptr;
		_size = _capacity = 0;
	}
	//类里面声明
	void push_back(const T& x);
	void pop_back();

	size_t size(){
		return _size;
	}

	T& operator [](size_t i)//加引用，避免产生的临时对象（具有常性）不能被修改
	{
		assert(i < _size);
		return _a[i];
	}
private:
	T* _a;
	size_t _size;
	size_t _capacity;
};

//类外面定义
template<class T>
void vector<T>::push_back(const T& x)
{	
	//如果空间不够，需要进行增容
	if (_size == _capacity){
		size_t newcapacity = _capacity == 0 ? 2 : _capacity * 2;
		T* tmp = new T[newcapacity];
		if (_a){
			memcpy(tmp, _a, sizeof(T)*_size);
			delete[] _a;
		}
		_a = tmp;

		_capacity = newcapacity;
	}
	_a[_size] = x;
	++_size;
}

template<class T>
void vector<T>::pop_back(){
	assert(_size > 0);
	--_size;
}

int main(){
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	//v.pop_back();

	for (size_t i = 0; i < v.size(); ++i){
		v[i] *= 2;
		cout << v[i] << " ";
	}
	cout << endl;
	return 0;
}

模板的特化

函数模板特化的步骤：

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

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

//字符串类型的特化
template<>
bool isEqual<char*>(char*& left, char*& right)
{
	if (strcmp(left, right) == 0)
		return true;
	return false;
}

模板参数分为非类型模板参数和模板参数
类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。非类型模板参数只能接受整数或者类整数：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
2. 非类型的模板参数必须在编译期就能确认结果。

类模板的特化：全特化和半特化（偏特化）

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

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

//1.必须要有一个普通的类模板
//template<>
//class Data<int, char> {
//public:
//	Data() { cout << "Data<int, char>" << endl; }
//private:
//	int _d1;
//	char _d2;
//};

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。

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

//半特化
//1.特化部分类型
template<class T>
class Data<T, char> {
public:
	Data() { cout << "Data<T, char>" << endl; }
private:
	T _d1;
	char _d2;
};

//半特化
//2.对模板参数做进一步的限制
template<class T1, class T2>
class Data<T1*, T2*>
{
public:
	Data() { cout << "Data<T1*, T2*>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

模板分离编译

注意！！！
模板不支持分离编译

分离编译是指一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程。
因为预处理，编译，汇编都没有实现交互，所以会导致编译器没有将模板函数进行实例化，但是编译器在链接时才会找函数的地址。
这就导致编译器会报链接错误，例如：

所以最好将模板的声明和定义放在同一个文件中，例如放在.hpp中，也或者在模板声明的地方将模板实例化

总结

模板复用了代码，节省资源，更快的迭代开发，增加了代码的灵活性
可以理解为编译时的多态

但是模板也会导致代码膨胀的问题，也会导致编译的时间变长
不易调试， 出现模板编译错误时，错误的信息非常凌乱，不易定位错误，参考上面说的报的链接错误