深入理解模板1

1,模版参数可以有三种类型:(1)类型;(2)编译时常量;(3)其他模版.
2,类型:

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

template<class T>
class stack
{
    T* data;
    size_t count;
public:
    void push(const T& t);
};

int main()
{
    stack<int> myStack;
    return 0;
}

3,编译时常量:

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

template<class T,size_t N>
class stack
{
    T data[N];
    //此时data运行时在堆栈而不是动态存储空间.
    //避免了与动态内存分配的高程关联,提高了运行性能.
    size_t count;
public:
    void push(const T& t);
};

int main()
{
    //实例化时,必须为N提供一个编译时常量值.
    //注:每个N的不同取值都会产生一个唯一的类类型.
    stack<int,10> myStack1;
    stack<int,50> myStack2;
    return 0;
}

4,默认模版参数.
(1)类模版中可以,函数模版中不行.
(2)一旦引入一个默认模板参数,它之后的模板参数也必须具有默认值.
(3)vector类模版使用了默认模板参数.
template<class T, class Allocator = allocator<T> > //尖括号分开
class vector;
两个参数:(1)对象类型;(2)使用的分配器.

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

template<class T=int,size_t N=10>
class stack
{
    T data[N];
    //此时data运行时在堆栈而不是动态存储空间.
    //避免了与动态内存分配的高程关联,提高了运行性能.
    size_t count;
public:
    void push(const T& t);
};

int main()
{

    stack<int> myStack1;//采用默认参数
    stack<int,50> myStack2;
    stack<> myStack3;//全部采用默认,保留尖括号.
    return 0;
}

5,模板类型的模板参数.

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

template<class T> //容器类
class Array
{
    enum{ INIT=10 };
    T* data;//动态,指针
    size_t count;
    size_t capacity;
public:
    Array():count(0)
    {
        data=new T[capacity=INIT];
    }
    void push_back(const T& t)
    {
        if(count==capacity)
        {
            size_t newCap=2*capacity;
            T* nData=new T[newCap];
            for(size_t i=0;i<count;i++)
                nData[i]=data[i];
            delete[] data;
            data=nData;
            capacity=newCap;
        }
        data[count++]=t;
    }
    void pop()
    {
        if(count>0) count--;
    }
    T* begin(){ return data; }
    T* end(){ return data+count; }
};

//template<class T, template<class u> class Seq> u可以省略
template<class T, template<class> class Seq>
class Container
{
    Seq<T> seq;
public:
    void append(const T& t){ seq.push_back(t); }
    T* begin(){ return seq.begin(); }
    T* end(){ return seq.end(); }
};

int main()
{
    Container<int, Array> container;
    container.append(1);
    container.append(2);
    int* p = container.begin();
    while(p != container.end())
        cout << *p++ << endl;
    return 0;
}

(2),模板类型的模板参数带有默认参数.

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

//采用一个固定大小的数组.
template<class T,size_t N=10> //容器类
class Array
{
    T data[N];//动态,指针
    size_t count;
public:
    Array():count(0){}
    void push_back(const T& t)
    {
        if(count<N)
            data[count++]=t;
    }
    void pop()
    {
        if(count>0) count--;
    }
    size_t getCapacity(){ return N; }
    T* begin(){ return data; }
    T* end(){ return data+count; }
};

//编译器无法顾及到模板类模板参数的内部参数,必须重复声明默认参数.
//这是默认参数仅能出现一次的唯一例外.
template<class T, template<class,size_t=10> class Seq>
class Container
{
    Seq<T> seq;
public:
    void append(const T& t){ seq.push_back(t); }
    T* begin(){ return seq.begin(); }
    T* end(){ return seq.end(); }
    size_t capacity(){ return seq.getCapacity(); }
};

int main()
{
    Container<int,Array> container;
    container.append(1);
    container.append(2);
    int* p = container.begin();
    while(p != container.end())
        cout << *p++ << endl;
    cout<<container.capacity()<<endl;
    return 0;
}

(3)vector作为模板的参数.

#include <iostream>
#include <vector>
#include <cstdlib>
using namespace std;

//vector作为模板的实例参数.
template<class T, template<class u,class=allocator<u> > class Seq>
class Container
{
    Seq<T> seq;
public:
    void push_back(const T& t){ seq.push_back(t); }
    typename Seq<T>::iterator begin(){ return seq.begin(); }
    typename Seq<T>::iterator end(){ return seq.end(); }
};

int main()
{
    Container<int,vector> vec_container;
    vec_container.push_back(1);
    vec_container.push_back(2);
    for(vector<int>::iterator ite=vec_container.begin();ite!=vec_container.end();ite++)
        cout << *ite << endl;
    return 0;
}