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 ;
 }

以下用于验证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[] = { , , , ,  };
 
     vector<int> x;
     vector<int>::iterator ite;
     x.insert(ite, ia, ia + );
     return ;
 }

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

 #include <iostream>
 #include <cstddef>
 
 using namespace std;
 
 class alloc {
 
 };
 
 template<class T, class Alloc = alloc, size_t BufSiz = >
 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 ;
 }

运行结果：

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 !=  ? n : (sz <  ? size_t( / sz) : size_t());
 }
 
 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 = >
 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, >::iterator::buffer_size() << endl;
     return ;
 }

运行结果

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 = >
 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==" << '\t';
     return ;
 }
 
 template<class T, class Sequence>
 bool operator<(const stack<T, Sequence>& x, const stack<T, Sequence>&y) {
     cout << "operator<" << '\t';
     return ;
 }
 
 int main(int argc, char **argv) {
     stack<int> x;
     stack<int> y;
 
     cout << (x == y) << endl;
     cout << (x < y) << endl;
     return ;
 }

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 ;
 }

运行结果

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