模板

模板是泛型编程的基础，即与类型无关的逻辑代码。

利用模板机制可以显著减少冗余信息，能大幅度地节约程序代码，进一步提高面向对象程序的可重用性和可维护性。

模板是实现代码重用机制的一种工具，它可以实现类型参数化；

模板分为函数模板和类模板。

为了使用函数名相同，参数不同，返回值可同可不同的函数时，我们起初用了重载的方式。

#include<iostream>
using namespace std;

int add(int a,int b)
{
	return a+b;
}

double add(double a,double b)
{
	return a+b;
}

int main()
{
	cout<<"ret1="<<add(1,2)<<endl;
	cout<<"ret2="<<add(2.3,3.0)<<endl;
	getchar();
	return 0;
}

但是运用重载的方式写起来比较不方便，尤其是重载的函数较多时，为了解决这类问题，我们用函数模板来实现这种功能。

#include<iostream>
using namespace std;
template <class T>
T add(const T& a,const T& b)
{
        cout<<"type:"<<typeid(a).name()<<endl;   //显示类型
	return a+b;
}

int main()
{
	cout<<"ret1="<<add(1,2)<<endl;//还可以显示实例化，显示指定T为int，即add<int>(1,2)
	cout<<"ret2="<<add(2.3,3.0)<<endl;   //add<double>(2.3,3.0)
	getchar();
	return 0;
}

以上函数中函数参数类型都是相同的，当我们遇到形如：add(1,2.3);一个参数为int，一个参数为double型，此时我们可以这样定义：

template <class T1,class T2>
T add(const T1& a,const T2& b)
{
	return a+b;
}

当然，肯定有人会想，模板函数可以构成重载吗？    答案是肯定的。

#include<iostream>
using namespace std;

int add(int a,int b)
{
	return a+b;
}

double add(double a,double b)
{
	return a+b;
}
template <class T>
T add(const T& a,const T& b)
{
	cout<<"type:"<<typeid(a).name()<<endl; 
	return a+b;
}

int main()
{
	cout<<"ret1="<<add(1,2)<<endl;
	cout<<"ret2="<<add(2.3,3.0)<<endl;
	getchar();
	return 0;
}

当模板构成重载，调用add的函数时，它会先调用非模板类的函数，性能比较高；而模板函数内部还得调用，有推演过程判断它是什么类型，效率上会有所降低。

2.模板类

对于普通函数来说,我们拿typedef重定义一个类型，当需要改的时候，需要将int改掉就可以了；

typedef int DataType;
 class SEQLIST
{
private:
    DataType *data;
};

而我们为了适应更多的类型，于是引入了模板类，我们这样定义，体现了其高度复用的优势：

template<class T>
class SeqList
{
private:
    T* data;
};

写一个模板类实现SeqList的动态顺序表吧：

#include<iostream>
using namespace std;

template <class T>
class SeqList
{
public:
	SeqList()
		:_data(NULL)
		,_size(0)
		,_capacity(0)
	{}
	SeqList(const SeqList<T>& s);
	SeqList<T>& operator=(const SeqList<T>& s);
	~SeqList()
	{
		if(_data != NULL)
		{
			delete[] _data;
		}
	}
	void CheckCapacity();
	void PushBack(const T& d);
	void PopBack();
	void PushFront(const T& d);
	void PopFront();
	void Print();
private:
	T *_data;
	int _size;
	int _capacity;
};
template <class T>
SeqList<T>::SeqList(const SeqList<T>& s)
{
	_data = new T[s._size*sizeof(T)];
	int i = 0;
	for(i = 0;i < s._size; i++)
	{
		_data[i] = s._data[i];
	}
	_size = s._size;
	_capacity = s._capacity;
}
template <class T>
SeqList<T>& SeqList<T>::operator=(const SeqList<T>& s)
{
	int i = 0;
	if(this == &s)
	{
		return *this;
	}
	_size = s._size;
	_capacity = s._capacity;
	delete _data;
	_data = new T[_capacity];
	for(i = 0; i < _size; i++)
	{
		_data[i] = s._data[i];
	}
	return *this;
}
template <class T>
void SeqList<T>::CheckCapacity()
{
	if(_size == _capacity)
	{
		T* tmp = new T[_capacity*2+3];
		//memcpy(tmp,_data,_size*sizeof(T));
		int i = 0;
		for(i = 0; i < _size; i++)
		{
			tmp[i] = _data[i];
		}
		delete[] _data;
		_data = tmp;
		_capacity = _capacity*2+3;
	}
}
template <class T>
void SeqList<T>::PushBack(const T& d)
{
	CheckCapacity();
	_data[_size] = d;
	_size++;
}
template <class T>
void SeqList<T>::PopBack()
{
	CheckCapacity();
	_size--;
}

template <class T>	
void SeqList<T>::PushFront(const T& d)
{
	int i ;
	CheckCapacity();	
	for(i = _size; i > 0; i--)
	{
		_data[i] = _data[i-1];
	}
	_data[0] = d;
	_size++;
}

template <class T>
void SeqList<T>::PopFront()
{
	int i;
	CheckCapacity();
	for(i = 0; i < _size; i++)
	{
		_data[i] = _data[i+1];
	}
	_size--;
}
template <class T>
void SeqList<T>::Print()
{
	int i = 0;
	for(i = 0; i < _size; i++)
	{
		cout<<_data[i]<<" ";
	}
	cout<<endl;
}

int main()
{
	SeqList<int> seq;
	SeqList<int> seq1;
	cout<<"seq:"<<endl;
	cout<<"尾插1234"<<endl;
	seq.PushBack(1);
	seq.PushBack(2);
	seq.PushBack(3);
	seq.PushBack(4);
	seq.Print();
	cout<<"尾删"<<endl;
	seq.PopBack();
	seq.Print();
	cout<<"头删"<<endl;
	seq.PopFront();
	seq.Print();
	cout<<"seq2:"<<endl;
	SeqList<int> seq2(seq);
	seq2.Print();
	cout<<"头插567"<<endl;
	seq.PushFront(5);
	seq.PushFront(6);
	seq.PushFront(7);
	seq.Print();
	seq1 = seq;
	cout<<"seq1:"<<endl;
	seq1.Print();
	getchar();
	return 0;
}

模板就说到这里啦，有好的建议还希望大家提出来，欢迎来访哦。