模板编写的一个示例

#include <iostream>
#include <cassert>
using namespace std;

template<typename T>
void Swap(T& lhs, T& rhs)
{
	T tmp=lhs;
	lhs=rhs;
	rhs=tmp;
}

template<typename T>              //函数模板的偏特化，对函数的参数类型为指针类型的模板进行特化
void Swap(T* lhs, T* rhs)
{
	assert(lhs!=NULL && rhs!=NULL);
	T tmp=*lhs;
	*lhs=*rhs;
	*rhs=tmp;
}
template<>                                      //对函数的参数类型为char*进行特化
void Swap<char>(char* lhs, char* rhs)
{
	assert(lhs!=NULL && rhs!=NULL);
	char tmp;
	int sizeLhs=strlen(lhs)+1;
	int sizeRhs=strlen(rhs)+1;
	char* pLEnd=lhs+sizeLhs-1;
	char* pREnd=rhs+sizeRhs-1;
	while(lhs<=pLEnd && rhs<=pREnd)
	{
		tmp=*lhs;
		*lhs=*rhs;
		*rhs=tmp;
		++lhs;
		++rhs;
	}
	if(lhs<pLEnd)
	{
		strcpy(rhs,lhs);
		while(lhs <=pLEnd)
		{
			*lhs='\0';
			++lhs;
		}
	}
	if(rhs<pREnd)
	{
		strcpy(lhs,rhs);
		while(rhs <=pREnd)
		{
			*rhs='\0';
			++rhs;
		}
	}
	
}
template<class T>
class Test
{
public:
	Test(const T& val):m_val(val){}
	void print()const;
private:
	T m_val;
};
template<class T>
void Test<T>::print()const
{
	cout<<m_val<<endl;
}
template<class T>             //类模板的偏特化，对数据成员的类型为指针类型进行特化
class Test<T*>
{
public:
	Test(const T* pData);
	Test(const Test& obj);
	~Test();
	Test& operator = (const Test& obj);
	void print()const;
private:
	T* m_pData;
};
template<class T>
Test<T*>::Test(const T* pData)
{
	cout<<*pData<<endl;
	if(pData ==NULL)
		m_pData=NULL;
	else
		m_pData=new T(*pData);
}
template<class T>
Test<T*>::Test(const Test& obj)
{
	if(obj.m_pData ==NULL)
		m_pData=NULL;
	else
		m_pData=new T(*obj.m_pData);
}
template<class T>
Test<T*>::~Test()
{
	if(m_pData !=NULL)
	{
		delete m_pData;
		m_pData=NULL;
	}

}
template<class T>
Test<T*>& Test<T*>::operator = (const Test<T*>& obj)
{
	if(this ==&obj)
		return *this;
	if(obj.m_pData ==NULL)
		m_pData=NULL;
	else
	{
		delete m_pData;
		m_pData=new T(*obj.m_pData);
		return *this;
	}
	
}
template<class T>
void Test<T*>::print()const
{
	if(m_pData !=NULL)
		cout<<*m_pData<<endl;
}

template<>                              //对数据成员的类型为char* 进行特化
class Test<char*>
{
public:
	Test(const char* pStr);
	Test(const Test& obj);
	~Test();
	Test& operator = (const Test& obj);
	void print()const;
private:
	char* m_pStr;
};
Test<char*>::Test(const char* pStr)
{
	if(pStr ==NULL)
	{
		m_pStr=new char[1];
		*m_pStr='\0';
	}
	else
	{
		int size=strlen(pStr)+1;
		m_pStr=new char[size];
		if(m_pStr !=NULL)
		{
			strcpy(m_pStr,pStr);
		}
	}
}
Test<char*>::Test(const Test& obj)
{
	int size=strlen(obj.m_pStr)+1;
	m_pStr=new char[size];
	if(m_pStr !=NULL)
	{
		strcpy(m_pStr,obj.m_pStr);
	}
}
Test<char*>::~Test()
{
	if(m_pStr !=NULL)
	{
		delete []m_pStr;
		m_pStr=NULL;
	}
}
Test<char*>& Test<char*>::operator=(const Test<char*>& obj)
{
	if(this ==&obj)
		return *this;
	delete []m_pStr;
	int size=strlen(obj.m_pStr)+1;
	m_pStr=new char[size];
	if(m_pStr !=NULL)
		strcpy(m_pStr,obj.m_pStr);
	return *this;
}
void Test<char*>::print()const
{
	if(m_pStr !=NULL)
		cout<<m_pStr<<endl;
}
int main()
{
	int val_one=3,val_two=4;
	//测试实例一
	Swap(val_one,val_two);
	cout<<val_one<<" "<<val_two<<endl;

	//测试实例二
	Swap(&val_one,&val_two);
	cout<<val_one<<" "<<val_two<<endl;

	//测试实例三
	char str1[30]="programing",str2[20]="My c++ template";
	Swap(str1,str2);
	cout<<str1<<" "<<str2<<endl;

	//测试实例四
	Test<int> obj(12343);
	obj.print();
	//测试实例五
	Test<int*> objO(&val_one);
	objO.print();
	//测试实例五
	Test<char*>objT("akon");
	objT.print();
	return 0;
}