C++模板与泛型编程（二）——类模板

类模板是用来生成类的蓝图的，与函数模板的不同之处是，编译器不能为类模板推断模板参数类型。

模板类也是模板，必须以关键字template开头，后接模板形参表。

1、类模板格式

template

class 类名

{ ... };

2、类模板实例化

只要有一种不同的类型，编译器就会实例化出一个对应的类。

SeqList sl1;

SeqList sl2;

当定义上述两种类型的顺序表时，编译器会使用int和double分别代替模板形参，重新编写SeqList类，最后创建名为SeqList和SeqList的类。

一个类模板的每个实例都形成一个独立的类。

类模板的名字不是一个类型名，。类模板用来实例化类型，而一个实例化的类型总是包含模板参数的。

一个类模板中的代码如果使用了另外一个模板，通常不将一个实际类型（或值）的名字用作其模板形参。相反的，我们通常将模板自己的参数当做被使用模板的实参。

3、类模板的成员函数

与其他任何类相同，我们既可以在类模板内部，也可以在类模板外部为其定义成员函数，且定义在类模板内的成员函数被隐式声明为内联函数。

类模板的成员函数本身是一个普通函数，但是，类模板的每个实例都有其自己版本的成员函数。因此，类模板的成员函数具有和模板相同的模板参数，因而，定义在类模板之外的成员函数就必须以关键字template，后接模板参数列表。

默认情况下，一个类模板的成员函数只有当程序用到它时才进行实例化。

4、类模板和友元

当一个类包含一个友元声明，类与友元各自是否是模板是相互无关的。如果一个类模板包含一个非模板友元，则友元被授权可以访问所有模板实例。如果友元自身是模板，类可以授权给所有友元模板实例，也可以只授权给特定实例。

类模板实现STL中Vector：

#include 
using namespace std;
#include 
template
class Vector
{
public:
    typedef T valueType;
    typedef valueType* Iteator;
    typedef const valueType* const_Iterator;
    typedef valueType& Reference;
    typedef const valueType& const_Reference;
    typedef size_t size_type;

public:
    Vector()   //构造函数
        :_start(0)
        ,_finish(0)
        ,_end_of_storage(0)
    {}

    Vector(size_type n, const T& value = T())  //构造函数，构造一个里面有n个相同值的顺序表
        :_start(new T[n])
    {
        for(size_type idx=0; idx &v)   //拷贝构造函数
    {
        size_type capacity = v._end_of_storage - v._start;
        _start = new T[capacity];
        size_type size = v._finish - v._start;

        for(size_type idx=0; idx& operator = (const Vector& v) //赋值运算符重载
    {
        if(this != &v)
        {
            size_type capacity = v._end_of_storage - v._start;
            size_type size = v._finish - v._start;
            if(Capacity() < size)
            {
                _start = new T[capacity];
                for(size_type idx=0; idx= _end_of_storage)
        {
            int capacity = Capacity()*2 + 3;
            Iteator pTemp = new T[capacity];
            size_type size = _finish - _start;
            memcpy(pTemp, _start, sizeof(T)*size);
            if(_start != NULL)
            {
                delete[] _start;
            }
            _start = pTemp;
            _finish = _start + size;
            _end_of_storage = _start + capacity;
        }
    }

protected:
    Iteator _start;
    Iteator _finish;
    Iteator _end_of_storage;
};

void FunTest1()
{
    Vector v1();
    Vector v2(10,4);
    Vector v3(v2);
    Vector v4;
    v4 = v2;

    cout<::Iteator it = v2.Begin();
    while(it != v2.End())
    {
        cout<<*it<<" ";
        it++;
    }
    cout< v1(3, 5);
    v1.PushBack(1);
    v1.PushBack(2);
    v1.PushBack(3);
    v1.PushBack(4);
    v1.PushBack(5);
    v1.PushBack(6);


    cout<::Iteator it = v1.Begin();
    while(it != v1.End())
    {
        cout<<*it<<" ";
        it++;
    }
    cout< v1(3, 5);
    v1.PushBack(1);
    v1.PushBack(2);
    v1.PushBack(3);
    v1.PushBack(4);
    v1.PushBack(5);
    v1.PushBack(6);

    cout<::Iteator it = v1.Begin();
    while(it != v1.End())
    {
        cout<<*it<<" ";
        it++;
    }
    cout< v1(3, 5);
    v1.PushBack(1);
    v1.PushBack(2);
    v1.PushBack(3);
    v1.PushBack(4);
    v1.PushBack(5);
    v1.PushBack(6);
    cout<