类模板上

一些类主要用于存储和组织数据元素，如数组类，链表类，Stack类，Queue类等
可将模板思想应用于类，使得类可不关注具体所操作数据的类型，而只关注类所需实现的功能
编译器对类模板处理方式与函数模板同(根据具体类型产生不同的类)
在类模板外部定义成员函数时，需加上template<typename T>声明
类模板编译机制与普通类不同，故需把类模板函数实现放在头文件中，如上例(否则链接出错)
只有被调用的类模板成员函数才会被编译生成可执行代码

template<typename T>
class Operator
{
public:
    T add(T a, T b)	 //难维护
    {
    	return a + b;
	}
    T minus(T a, T b);
};

template<typename T> 
T Operator<T>::minus(T a, T b)
{
    return a - b;
}

int main(int argc, char *argv[])
{
    Operator<int> op1;	//使用具体类型定义对象，无法自动推导 
    Operator<double> op2;
    
    cout<<op1.add(5, 4)<<endl;
    cout<<op1.minus(4, 5)<<endl;
    
    cout<<op2.add(1.3, 0.01)<<endl;
    cout<<op2.minus(0.01, 1.3)<<endl;
    return EXIT_SUCCESS;
}

结果：
9 -1 1.31 -1.29
——————/Array.h

#ifndef _ARRAY_H_
#define _ARRAY_H_

template<typename T>
class Array
{
private:
    int mLength;
    T* mSpace;
public:
    Array(int length);
    Array(const Array& obj);
    ~Array();
    int length();
    T& operator[](int i);
    Array& operator= (const Array& obj);
    bool operator== (const Array& obj);
    bool operator!= (const Array& obj);
};

#endif

——————/Array.hpp

#ifndef _ARRAY_DEF_H_
#define _ARRAY_DEF_H_

#include "Array.h"  //方法

template<typename T>
Array<T>::Array(int length)
{
    if( length < 0 )
    {
        length = 0;
    }
    mLength = length;
    mSpace = new T[mLength];
}

template<typename T>
Array<T>::Array(const Array& obj)
{
    mLength = obj.mLength;
    mSpace = new int[mLength];
    for(int i=0; i<mLength; i++)
    {
        mSpace[i] = obj.mSpace[i];
    }
}

template<typename T>
int Array<T>::length()
{
    return mLength;
}

template<typename T>
Array<T>::~Array()
{
    mLength = -1;
    delete[] mSpace;
}

template<typename T>
T& Array<T>::operator[](int i)
{
    return mSpace[i];
}

template<typename T>
Array<T>& Array<T>::operator= (const Array<T>& obj)
{
    delete[] mSpace;
    mLength = obj.mLength;
    mSpace = new int[mLength];
    for(int i=0; i<mLength; i++)
    {
        mSpace[i] = obj.mSpace[i];
    }    
    return *this;
}

template<typename T>
bool Array<T>::operator== (const Array<T>& obj)
{
    bool ret = true;
    if( mLength == obj.mLength )
    {
        for(int i=0; i<mLength; i++)
        {
            if( mSpace[i] != obj.mSpace[i] )
            {
                ret = false;
                break;
            }
        }
    }
    else
    {
        ret = false;
    }
    return ret;
}

template<typename T>
bool Array<T>::operator!= (const Array& obj)
{
    return !(*this == obj);
}
#endif

——————/main.c

#include "Array.hpp"  //方法
int main(int argc, char *argv[])
{
    Array<int> ai(5);
    for(int i=0; i<ai.length(); i++)
    {
        ai[i] = i + 1;
    }
    for(int i=0; i<ai.length(); i++)
    {
        cout<<ai[i]<<endl;
    }
    
    Array<double> ad(10);
    for(int i=0; i<ad.length(); i++)
    {
        ad[i] = (i + 1) / 100.0;
    }
    for(int i=0; i<ad.length(); i++)
    {
        cout<<ad[i]<<endl;
    }
    return EXIT_SUCCESS;
}

——————/类模板的特化
用template<>声明一个类，表特化类
当类模板处理某种类型有缺陷时，可通过特化来克服
编译器优先选择特化类生成对象

template<typename T>
class Test
{
public:
    T test(T v)
    {
        cout<<"T test(T v)"<<endl;
        cout<<"sizeof(T) = "<<sizeof(T)<<endl;
        return v;
    }
};

template<>
class Test<int>  //int的特化 
{
public:
    int test(int v)
    {
        cout<<"int test(int v)"<<endl;
        cout<<"sizeof(int) = "<<sizeof(int)<<endl;
        return v;
    }
};

class MyTest : public Test<int>  //继承自特化类 
{
};

int main(int argc, char *argv[])
{
    //Test<int> t1;
    MyTest t1;
    cout<<t1.test(1)<<endl;
    return EXIT_SUCCESS;
}

结果：
int test(int v)
sizeof(int) = 4
1