模板编写的一个示例

#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;
}