C++模板特例化

模板是用来写一些独立化特定类型的代码，但是对于有些类型，在处理时，细节上却有所差别，常见的如char*

如，现在你打算写一个栈，可以用于任何数据类型，那你肯定首先想到的就是模板啦

template<typename T>
class Stack
{
public:
       void push( const T &T);
        void pop( void);
};

但是如果你用char*去实例化Stack类，那多半会出问题吧，如;

Stack<char*> s;

char *p  = “fdjfjlaj";

s.push(p);

s.push(p);

那你每次push进去只是一个地址，这可能不是想要的吧，这是，你就需要对于char*进行特化，特例化后的类如下

template<>
class Stack<char*>
{
    void push(const char *p);
    void pop(void);
};

void Stack<char*>::push(const char*p)
{
}

void Stack<char*>::pop(void)
{
}

一下是一个完整的例子，环境：VS2008

//模板类
template<typename T>
class A
{
private:
    T data;
public:
     A(void):data()
     {
        cout << "A(void)" << endl;
     }
     ~A(void)
     {
        cout << "~A(void) : " << data << endl;
     }
   
     A(const T &t)
     {
          data = t;
          cout << "A(const T &t)" << endl;
     }
     A& operator = (const A &a)
     {
          data = a.data;
          cout << "A& operator = (const A &a)" << endl;
     }
     A(const A &a)
     {
          *this = a;
       
          cout << "A(const A &a)" << endl;
     }
};

//用char*特例化模板类A
template<>
class A<char*>
{
private:
    char *data;

    void free_data(void);
public:
     A(void);
     ~A(void);
     A( const char *p);
   
     A<char*>& operator = (const A<char*> &a);
     A<char*>& operator = (const char* p);
     A(const A &a);
};

//定义特例化类A<char*>的成员函数
A<char*>::A(void)
{
     data = new char[1];
     *data = 0;
     cout << "class A<char*>::A(void)" << endl;
}
A<char*>::~A(void)
{
     cout << "class A<char*>::~A(void) : " << data <<endl;
   
     if( NULL != data)
     {
          delete[] data;
          data = NULL;
     }
}

A<char*>::A(const char*p)
{
     cout << "A<char*>::A(const char*p)" << endl;
     int len = 0;
     if( NULL != p)
     {
        len = strlen(p);
     }
   
     data = new char[len+1];
    
     if( 0 != len)
     {
        memcpy(data, p, len);
     }
    data[len] = 0;
}

void A<char*>::free_data(void)
{
     if( NULL == data)
     {
        return;
     }
     delete[] data;
     data = NULL;

}
A<char*>& A<char*>::operator = (const A& a)
{
     cout << "A<char*>& A<char*>::operator = (const A& a)"<<endl;
     if( this == &a)
     {
        return *this;
     }
   
     return (*this = a.data);
 
}

A<char*>& A<char*>::operator = (const char* p)
{

     cout << " A<char*>& A<char*>::operator = (const char* p)" << endl;
     if( NULL == p)
     {
        return *this;
     }
   
     free_data();
     int len = strlen( p);
   
     data = new char[len+1];
     memcpy( data, p, len);
     data[len] = 0;
   
     return *this;

}

A<char*>::A(const A &a)
{
    *this = a;
}