C++函数模板和类模板

一、函数模板
1.概念
实际是建立一个模型，然后根据这个模板去实例化一些对象，它的函数类型和形参类型不具体指定，用一个虚拟的类型来代表，这个通用的函数就称为函数模板，只要是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需要在模板中定义一次，在调用函数时，编译器会根据实参的类型对函数进行推演，从而实现了函数不同的功能。
例如下面能实现加法功能的模板：

template<class T> //class和typename都可以
T add(T left, T right)
{ 
	return left + right;
}

上面的class和struct不能互换，这也是C++中struct和class的一个区别。
2.使用规则
（1）普通函数调用时支持类型的隐式转换，函数模板不支持类型的隐式转换。

void Print(int a, int b)
{
	cout << " a = " << a << " b = " << b << endl;
}

int main()
{
	int a = 10;
	int b = 20;
	char c = 'A';
	Print(a, b);//a = 10,b = 20
	Print(a, c);//a = 10,c = 65;
	return 0;
}

将上面的函数Print改为函数模板：

template<class T>
void Print(T a, T b)
{
	cout << " a = " << a << " b = " << b << endl;
}

int main()
{
	int a = 10;
	int b = 20;
	char c = 'A';
	Print(a, b);
	//Print(a, c);//该语句将不会通过编译
	return 0;
}

解决上述问题的方法有两种：
第一种：称为显式实例化

template<class T>
void Print(T a, T b)
{
	cout << " a = " << a << " b = " << b << endl;
}

int main()
{
	int a = 10;
	int b = 20;
	char c = 'A';
	Print(a, b);
	//Print(a, c);//该语句将不会通过编译
	Print<int>(a,c);//相当于告诉编译器按照int类型进行推演函数
	return 0;
}

第二种：将函数模板的参数列表进行扩充

template<class T1,class T2>
void Print(T1 a, T2 b)
{
	cout << " a = " << a << " b = " << b << endl;
}

int main()
{
	int a = 10;
	int b = 20;
	char c = 'A';
	Print(a, b);
	Print(a, c);//将来编译器就会生成对应类型的函数
	return 0;
}

3.重载的特性

template<class T>
void Print(T a, T b)
{
	cout << " a = " << a << " b = " << b << endl;
}

template<class T>
void Print(T a, T b,T c)
{
	cout << " a = " << a << " b = " << b <<" c = " << c << endl;
}

函数模板机制：
编译器会对函数模板进行两次编译
1.在声明的地方对模板代码本身进行编译。
2.在调用的地方对参数替换后的代码进行编译。
说明模板函数是由函数模板产生的。
二、类模板

template<class T>
class SeqList
{
public:
	SeqList(int capacity = 10)
		:_pData(new T[capacity])
		, _capacity(capacity)
		, _size(0)
	{}

	~SeqList();

	void _CheckCapacity()
	{
		if (_size == _capacity)
		{
			size_t newCapacity = (_capacity << 1);

			//申请空间
			T* pTemp = new T[newCapacity];

			//拷贝元素
			memcpy(pTemp, _pData, _size*sizeof(T));

			//释放旧空间
			delete[] _pData;
			_pData = pTemp;
			_capacity = newCapacity;
		}
	}

	void PushBack(const T& data)//为什么给成引用?因为有可能是自定义类型的引用，所以传递效率要高一些
	{
		_CheckCapacity();
		_pData[_size++] = data;
	}

	void PopBack()
	{
		if (_size)
		{
			--_size;
		}
	}

	T& operator[](size_t index)
	{
		assert(index < _size);
		return _pDate[index];
	}

	const T& operator[](size_t index)const
	{
		assert(index < _size);
		return _pData[index];
	}

	T& Front()
	{
		return _pData[0];
	}

	const T& Front()const
	{
		return _pData[0];
	}

	T& Back()
	{
		return _pData[_size - 1];
	}

	const T& Back()const
	{
		return _pData[size - 1];
	}

	void Insert(size_t pos, const T& data)
	{
		if (pos<0 || pos>_size)
		{
			cout << "无法插入" << endl;
		}
		else
		{
			_CheckCapacity();
			for (int i = _size; i > pos; i--)
			{
				_pData[i] = _pData[i - 1];
			}
			_pData[pos] = data;
			_size++;
		}
	}
	void Erase(size_t pos)
	{
		if (pos<0 || pos>_size)
		{
			cout << "无法删除" << endl;
		}
		else
		{
			for (int i = pos; i < _size; i++)
			{
				_pData[i] = _pData[i + 1];
			}
		}
	}

private:
	T* _pData;
	size_t _capacity;
	size_t _size;
};

template<class T>
SeqList<T>::~SeqList()
{
	if (_pData)
	{
		delete[] _pData;
		_pData = nullptr;
		_capacity = 0;
		_size = 0;
	}
}

模板类就是类模板实例化后的一个产物，类模板就是一个飞机模型，模板类就是这个模型做出来的飞机。