c++stl笔记 template

1、测试在class template中拥有static data members

#include <iostream>
using namespace std;

template <typename T>
class testClass{
    public:
    static int _data;
    //int _data;
    };

//静态变量的初始化
template<typename T> int testClass<T>::_data = 0;

//wrong way to initailize static member as stl source code analyze
//stl源码分析里是这样初始化的，与我所用的版本不同
//testClass<int>::_data = 1;
//testClass<char>::_data = 2;

int main()
{
    //定义一个int型class
    testClass<int>::_data = 1;
    //定义一个char型class
    testClass<char>::_data = 2;
    cout << testClass<int>::_data << endl;
    cout << testClass<char>::_data << endl;

    //如果非static直接这样定义并初始化
    testClass<int> obji1, obji2;
    testClass<char> objc1, objc2;
    cout << obji1._data << endl;
    cout << obji2._data << endl;
    cout << objc1._data << endl;
    cout << objc2._data << endl;

    obji1._data = 3;
    objc2._data = 4;
    cout << obji1._data << endl;
    cout << obji2._data << endl;
    cout << objc1._data << endl;
    cout << objc2._data << endl;
    //cout << testClass<int>::_data << endl;
    //cout << testClass<char>::_data << endl;

}

2、测试class template partial specializtion类模板部分特例化在class template的一般化设计之外，特别针对某些template参数做特殊设计

#include <iostream>
using namespace std;

//一般设计
template <class I, class O>
struct testClass{
    testClass(){ cout << "I, O" << endl;}
};

//特殊化设计
template <class T>
struct testClass<T*, T*>
{
    testClass() { cout << "T*, T*" << endl; }
};

//特殊化设计
template <class T>
struct testClass<const T*, T*>
{
    testClass() { cout << "const T*, T*" << endl; }
};

//无意中发现struct可以有继承，多肽，构造函数等class用法；
//与class的区别是struct默认的访问控制是public
//  class是private，class可以用做模板参数定义，struct不可以。
//  有private的类成员变量的class无法用{}初始化，struct可以，这个不算区别
struct A{
    A() { cout << "A" << endl; }
    virtual void a() = 0;
};

struct B:public A{
    void a() { cout << "a" << endl; }
};

int main()
{
    testClass<int, char> obj1;
    testClass<int*, int*> obj2;
    testClass<const int*, int*> obj3;
    B b;
}

3、测试class template之内可否再有template members

#include <iostream>
using namespace std;

class alloc{};

template <class T, class Alloc = alloc>
class vector{
public:
    typedef T value_type;
    typedef value_type* iterator;
    template <class I>
    void insert(iterator position, I first, I last)
    { cout << "insert()" << endl; }
};

int main()
{
    int ia[5] = {0,1,2,3,4};
    vector<int> x;
    vector<int>::iterator ite;
    x.insert(ite, ia, ia+5);
}

4、测试template参数可否根据前一个template参数而设定默认值

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

class alloc{};

template <class T, class Alloc = alloc, size_t BufSize = 0>
class deque{
public:
    deque() { cout << "deque" << endl; }
};

template<class T, class Sequence = deque<T> >
class stack{
public:
    stack() { cout << "stack" << endl; }
private:
    Sequence c;
};

int main()
{
    stack<int> x;
}

5、测试template可否拥有none-type template参数

#include <iostream>
#include <cstddef> //for size_t
using namespace std;

class alloc{};

inline size_t __deque_buf_size(size_t n, size_t sz)
{
    return n!= 0 ? n:(sz < 512 ? size_t(512/sz):size_t(1));
}

template<class T, class Ref, class Ptr, size_t BufSiz>
struct __deque_iterator{
    typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
    typedef __deque_iterator<T, const T&, const T*, BufSiz> const_iterator;
    static size_t buffer_size() { return __deque_buf_size(BufSiz, sizeof(T)); }
};

template <class T, class Alloc = alloc, size_t BufSiz = 0>
class deque {
public:
    typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
};

int main()
{
    cout << deque<int>::iterator::buffer_size() << endl;
    cout << deque<int, alloc, 64>::iterator::buffer_size() << endl;
}

6、实现bound friend templates，也就是说class template 的某个具现体（instantiation）与其friend function template的某个具现体有一对一的关系，下面是一个测试程序

#include <iostream>
#include <cstddef>
using namespace std;
class alloc{};

template <class T, class Alloc = alloc, size_t BufSiz = 0>
class deque{
public:
    deque() { cout << "deque" << ' '; }
};

//以下声明如果不出现，GCC也可以通过，如果出现，GCC也可以通过，这一点和
//C++ primer 3/e p.834的说法有出入，书上说一定要有这些前置声明
//但我的环境不是这样，需要前置声明，跟他们说的一致
//
template<class T, class Sequence>
class stack;

template<class T, class Sequence>
bool operator == (const stack<T, Sequence>& x, const stack<T, Sequence>& y);

template<class T, class Sequence>
bool operator < (const stack<T, Sequence>& x, const stack<T, Sequence>& y);
/

template<class T, class Sequence = deque<T> >
class stack{
    //写成这样是可以的
    friend bool operator== <T> (const stack<T>&, const stack<T>& );
    friend bool operator < <T> (const stack<T>&, const stack<T>& );
    //写成这样也是可以的
    friend bool operator == <T> (const stack&, const stack&);
    friend bool operator < <T> (const stack&, const stack&);
    //写成这样也是可以的
    friend bool operator == <> (const stack&, const stack&);
    friend bool operator < <> (const stack&, const stack&);
    //写成这样就不可以了
    //friend bool operator == (const stack&, const stack&);
    //friend bool operator < (const stack&, const stack&);
public:
    stack() { cout << "stack" << endl; }
private:
    Sequence c;
};

template <class T, class Sequence>
bool operator == (const stack<T, Sequence>& x, const stack<T, Sequence>& y)
{
    return cout << "operator==" << '\t';
}

template <class T, class Sequence>
bool operator < (const stack<T, Sequence>& x, const stack<T, Sequence>& y)
{
    return cout << "operator <" << '\t';
}

int main()
{
    stack<int> x; //deque stack
    stack<int> y; //deque stack

    cout << (x == y) << endl; //operator == 1
    cout << (x < y) << endl; // operator < 1

    stack<char> y1; //deque stack
    //cout << (x==y1) << endl; //error:no match for...
    //cout << (x < y1) << endl; //error:no match for...
}

7、测试class template explicit specialization 类模板显示特例化

//测试class template explicit specialization 类模板显示特例化
#include <iostream>
using namespace std;

//将__STL_TEMPLATE_NULL定义为template<>
//若定义blank，如下，则只适用于GCC
#define __STL_TEMPLATE_NULL template<>/*blank */

template<class Key> struct hash{
    void operator() () { cout << "hash<T>" << endl; }
};

//explicit specialization
__STL_TEMPLATE_NULL struct hash<char> {
    void operator() () { cout << "hash<char>" << endl; }
};

__STL_TEMPLATE_NULL struct hash<unsigned char> {
    void operator () () { cout << "hash<unsigned char>" << endl; }
};

int main()
{
    hash<long> t1;
    hash<char> t2;
    hash<unsigned char> t3;
    t1();   //hash<T>
    t2();   //hash<char>
    t3();   //hash<unsigned char>
}