深入理解模板4

1,函数模板的半有序:
生成模板函数的时候,编译器将从这些模板中选择特化程度最高的模板.
template<class T> f(T):
template<class T> f(T*);
template<class T> f(const T*);
实例代码:

#include <iostream>
#include <vector>
#include <cstddef>
#include <algorithm>
using namespace std;

template<class T>
void f(T){ cout<<"f(T)"<<endl; }

template<class T>
void f(T*){ cout<<"f(T*)"<<endl; }

template<class T>
void f(const T*){ cout<<"f(const T*)"<<endl; }

int main()
{
    int i=0;
    f(i);
    f(&i);
    const int j=0;
    f(j);
    f(&j);
    return 0;
}

2,模板的显式特化:以"template<>"开头.
(1)函数模板的显式特化.
实例代码:

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

template<typename T> const T& myMin(const T& a, const T& b)
{
    return (a < b) ? a : b;
}

/*
const char* myMin(const char* a, const char* b)
{
    return (strcmp(a, b) < 0) ? a : b;
}
*/
//可以用一个显式模板作为替代
template<>
const char* const& myMin<const char*>(const char* const& str1,const char* const& str2)
{
    return strcmp(str1,str2)<0? str1:str2;
}

int main()
{
    const char *s2 = "say \"Ni-!\"", *s1 = "knights who";
    cout << myMin(1, 2) << endl;      // (template)
    cout << myMin(s1, s2) << endl;    // (constchar*)
    cout << myMin<>(s1, s2) << endl;  // 强迫编译器使用模板,这时比较的也不是地址.
}

(2)类模板的显式特化:
template<> class vector<bool,allocator<bool> >...

3,类模板的半特化:
template<class A> class vector<bool,A>

4,类模板的半有序:

#include <iostream>
using namespace std;

template<class T,class U>
class  C
{
public:
    void f(){ cout<<"Primary Template."<<endl; }
};

template<class T,class U>
class  C<T,U*>
{
public:
    void f(){ cout<<"template<class T,class U> class  C<T,U*>."<<endl; }
};

template<class T,class U>
class  C<T*,U*>
{
public:
    void f(){ cout<<"template<class T,class U> class  C<T*,U*>."<<endl; }
};

template<class T>
class  C<T,int>
{
public:
    void f(){ cout<<"template<class T,int>"<<endl; }
};

int main()
{
    C<int,double>().f();
    C<int,double*>().f();
    C<int*,double*>().f();
    C<double,int>().f();
    return 0;
}

5,通过继承和实例化一个现存的模板来创建一个新的模板.

#include <cstring>
#include <cstddef>
#include <vector>
#include <iostream>
#include <set>
#include <iterator>
#include <ctime>
using namespace std;

class LimitRand //生成一个出现一次的随机数
{
    set<int> used;
    int limit;
public:
    LimitRand(int lim):limit(lim){}
    int operator()()
    {
        while(1)
        {
            int i=(int)(rand())%limit;
            if(used.find(i)==used.end())
            {
                used.insert(i);
                return i;
            }
        }
    }
};

template<class T> //原始模板
class Sortable:public vector<T>
{
public:
    void sort();
};

template<class T>
void Sortable<T>::sort()
{
    for(size_t i = this->size(); i > 0; --i)
        for(size_t j = 1; j < i; ++j)
            if(this->at(j-1) > this->at(j))
            {
                T t = this->at(j-1);
                this->at(j-1) = this->at(j);
                this->at(j) = t;
            }
}

template<class T> //模板的半特化
class Sortable<T*>:public vector<T*>
{
public:
    void sort();
};

template<class T>
void Sortable<T*>::sort()
{
    for(size_t i = this->size(); i > 0; --i)
        for(size_t j = 1; j < i; ++j)
            if( *(this->at(j-1)) > *(this->at(j)))
            {
                T* t = this->at(j-1);
                this->at(j-1) = this->at(j);
                this->at(j) = t;
            }
}


template<>
void Sortable<const char*>::sort()
{
    for(size_t i = this->size(); i > 0; --i)
        for(size_t j = 1; j < i; ++j)
            if( strcmp(this->at(j-1),this->at(j))>0 )
            {
                const char* t = this->at(j-1);
                this->at(j-1) = this->at(j);
                this->at(j) = t;
            }
}


char* words[] = { "is", "running", "big", "dog", "a", };
int main()
{
    srand(time(0));
    ostream_iterator<int> out_int(cout," ");
    LimitRand rnd(50);

    Sortable<int> is;
    for(size_t i = 0; i < 15; ++i)
        is.push_back(rnd());
    copy(is.begin(),is.end(),out_int);
    cout<<endl;
    is.sort();
    copy(is.begin(),is.end(),out_int);
    cout<<endl;

    Sortable<int*> ips;
    for(size_t i = 0; i < 15; ++i)
        ips.push_back(new int(rnd()));
    for(unsigned i=0;i<ips.size();i++)
        cout<<*ips[i]<<" ";
    cout<<endl;
    ips.sort();
    for(unsigned i=0;i<ips.size();i++)
        cout<<*ips[i]<<" ";
    cout<<endl;

    Sortable<const char*> scp;
    for(size_t i = 0; i < sizeof(words)/sizeof(words[0]); ++i)
        scp.push_back(words[i]);
    for(size_t i = 0; i < scp.size(); ++i)
        cout << scp[i] << ' ';
    cout << endl;
    scp.sort();
    for(size_t i = 0; i < scp.size(); ++i)
        cout << scp[i] << ' ';
    cout << endl;

    return 0;
}

6,类模板的防止模板代码膨胀机制:只有被调用的类模板的成员函数才生成代码.
实例代码:

#include <iostream>
using namespace std;

class X
{
public:
    void f(){ cout<<"X.f"<<endl; }
};

class Y
{
public:
    void g(){ cout<<"Y.g"<<endl; }
};

template<class T>
class My
{
    T t;
public:
    void useX(){ t.f(); }
    void useY(){ t.g(); }
};

int main()
{
    My<X>().useX(); //显然没有实例化成员函数useY(),否则会报错.
    //My<X>().useY();//error: 'class X' has no member named 'g'
    My<Y>().useY();
    return 0;
}

7,使用模板的原因之一是:不用手工复制代码;但是代码仍然被复制了,只不过是编译器完成这个工作.
可以将指针类型存储到某个独立的类中,可以减少程序实现的体积.
关键:用void*进行完全特化,然后从void*实现中派生出所有其他类型的指针.

#include <cassert>
#include <cstddef>
#include <cstring>
#include <iostream>
using namespace std;

//基本模板类
template<class T> class Stack
{
    T* data;
    size_t count;
    size_t capacity;
    enum { INIT = 5 };
public:
    Stack()
    {
        count = 0;
        capacity = INIT;
        data = new T[INIT];
    }
    void push(const T& t)
    {
        if(count == capacity)
        {
            size_t newCapacity = 2 * capacity;
            T* newData = new T[newCapacity];
            for(size_t i = 0; i < count; ++i)
                newData[i] = data[i];
            delete [] data;
            data = newData;
            capacity = newCapacity;
        }
        assert(count < capacity);
        data[count++] = t;
    }
    void pop()
    {
        assert(count > 0);
        --count;
    }
    T top() const
    {
        assert(count > 0);
        return data[count-1];
    }
    size_t size() const { return count; }
};

// void*完全特化
template<>
class Stack<void *>
{
    void** data;
    size_t count;
    size_t capacity;
    enum { INIT = 5 };
public:
    Stack()
    {
        count = 0;
        capacity = INIT;
        data = new void*[INIT];
    }
    void push(void* const & t)
    {
        if(count == capacity)
        {
            size_t newCapacity = 2*capacity;
            void** newData = new void*[newCapacity];
            std::memcpy(newData, data, count*sizeof(void*));
            delete [] data;
            data = newData;
            capacity = newCapacity;
        }
        assert(count < capacity);
        data[count++] = t;
    }
    void pop()
    {
        assert(count > 0);
        --count;
    }
    void* top() const
    {
        assert(count > 0);
        return data[count-1];
    }
    size_t size() const { return count; }
};

// 继承完全特化的半特化版本
template<class T>
class Stack<T*> : private Stack<void *>
{
    typedef Stack<void *> Base;
public:
    void push(T* const & t) { Base::push(t); } //这里T* const& t表示指针本身是常量
    void pop() { Base::pop(); }
    T* top() const { return static_cast<T*>(Base::top()); }
    size_t size() { return Base::size(); }
};

template<class StackType>
void emptyTheStack(StackType& stk)
{
    while(stk.size() > 0)
    {
        cout << stk.top() << endl;
        stk.pop();
    }
}

// 函数模板重载,半有序
template<class T>
void emptyTheStack(Stack<T*>& stk)
{
    while(stk.size() > 0)
    {
        cout << *stk.top() << endl;
        stk.pop();
    }
}

int main()
{
    Stack<int> s1;
    s1.push(1);
    s1.push(2);
    emptyTheStack(s1);

    Stack<int *> s2;
    int i = 3;
    int j = 4;
    s2.push(&i);
    s2.push(&j);
    emptyTheStack(s2);

    return 0;
}