C++ template一些体悟(3)

其实没啥体悟，因为还没有感受到这些例子的作用，记一下先

#include <iostream>

using namespace std;
class alloc {

};

template<class T, class Alloc = alloc>
class vector {
public:
    void swap(vector<T, Alloc>&) {
        cout << "swap()" << endl;
    }
};

template<class T,class Alloc>
inline void swap(vector<T, Alloc>& x,vector<T, Alloc>& y){
    x.swap(y);
}


int main(int argc, char **argv) {
    vector<int> x,y;
    swap(x,y);
    return 0;
}

 以下用于验证class template内能否在有template

#include <iostream>

using namespace std;
class alloc {

};

template<class T, class Alloc = alloc>
class vector {
public:
    typedef T value_type;
    typedef value_type* iterator;
　　//测试class template内能否再有template
    template<class I>
    void insert(iterator position, I first, I last) {
        cout << "insert()" << endl;
    }
};

int main(int argc, char **argv) {
    int ia[5] = { 0, 1, 2, 3, 4 };

    vector<int> x;
    vector<int>::iterator ite;
    x.insert(ite, ia, ia + 5);
    return 0;
}

测试template参数可否根据前一个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" << endl;
    }
};

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

int main(int argc, char **argv) {
    stack<int> x;
    return 0;
}

运行结果：

deque
stack

 先成员变量构造，再构造函数。

//注释说测试class template可否拥有non-type template参数

//但是我没找到哪个是non-type

#include <iostream>
#include <cstddef>

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(int argc, char **argv) {
    cout << deque<int>::iterator::buffer_size() << endl;
    cout << deque<int, alloc, 64>::iterator::buffer_size() << endl;
    return 0;
}

运行结果

128
64

 看过完整的STL代码，只觉得这样写很牛逼，但是不知道为什么要这样写。

查了下non-type原来指BufSize。但其实还是没弄懂定义的iterator有什么优秀之处

//bound friend templates 等着找到使用的地方

#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" << ' ';
    }
};

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, Sequence>& x,
     const stack<T, Sequence>& y);
     friend bool operator< <T>(const stack<T, Sequence>& x,
     const stack<T, Sequence>& y);
     */
    //这个不可以
    /*
     friend bool operator==(const stack<T, Sequence>& x,
     const stack<T, Sequence>& y);
     friend bool operator<(const stack<T, Sequence>& x,
     const stack<T, Sequence>& y);
     */
    //操作符后不能去掉<>
    //参数的<>可以去掉
    friend bool operator==<T, Sequence>(const stack& x,
            const stack<T, Sequence>& y);
    friend bool operator< <>(const stack<T>& x, const stack<T, Sequence>& y);
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) {
    cout << "operator==" << '	';
    return 1;
}

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

int main(int argc, char **argv) {
    stack<int> x;
    stack<int> y;

    cout << (x == y) << endl;
    cout << (x < y) << endl;
    return 0;
}

explicit specialization(显示特化)

还有个偏特化，可以了解一下

C++模板之特化与偏特化详解

原来偏特化就是C++ template一些体悟(2)写的东西，换了个名字，那里叫特殊设计

还涉及到 A a();是声明一个函数而非对象的问题，引以为戒

#include <iostream>
#include <cstddef>

using namespace std;

#define __STL_TEMPLATE_NULL template<>

template<class Key>
class Hash {
public:
    Hash() {
        cout << "Construct Hash<T>" << endl;
    }

    void operator()() {
        cout << "Hash<T>" << endl;
    }
};

//explicit specialization
__STL_TEMPLATE_NULL
class Hash<char> {
public:
    Hash() {
        cout << "Construct Hash<char>" << endl;
    }
    void operator()() {
        cout << "Hash<char" << endl;
    }
};

int main(int argc, char **argv) {
//    Hash<long> obj1(); //声明了一个函数而非对象
    Hash<long> obj1;
    Hash<char> obj2;
    obj1();
    obj2();
    return 0;
}

运行结果

Construct Hash<T>
Construct Hash<char>
Hash<T>
Hash<char