__type_traits

转 作者 楚东方 | 发表于 | 分类于 2015级

之前我们对iterator_traits有了一些了解，现在我们要了解__type_traits。

Iterator_traits负责萃取迭代器的特性，__type_traits则负责萃取型别的特性。

 

对于型别的特性，我们关注的点可能在于对该型别是否需要复杂处理。如果答案是否定的，我们在对这些型别进行构造、析构、拷贝赋值等操作时，就可以采取最有效率的措施，比如不使用析构函数，直接free等。

 

__type_traits提供了一种机制，允许针对不同的型别属性，在编译时期完成函数派送决定。这对于撰写template很有帮助。例如当我们对一个型别未知的数组进行copy时，如果我们事先知道该元素型别的构造函数是否是不重要的，我们可能可以使用memcpy或是memmove等函数快速处理

 

根据之前对于iterator_traits的学习，我们想必是希望与其有相同的形式可以使用：

[cpp]  view plain  copy
 print ?
  1. __type_traits<T>::has_trivial_default_constructor;  
  2. __type_traits<T>::has_trivial_copy_constructor;  
  3. __type_traits<T>::has_trivial_assignment_operator;  
  4. __type_traits<T>::has_trivial_destructor;  
  5. __type_traits<T>::is_POD_type;  

且我们希望他们返回的是一个对象（或者说我们需要的是它的型别用以判断）而不是单纯的bool类型的值，可以帮助我们实现重载

[cpp]  view plain  copy
 print ?
  1. struct __true_type {  
  2. };  
  3. struct __false_type {  
  4. };  

STL对最初的__type_traits是这样处理的：

[cpp]  view plain  copy
 print ?
  1. template <class type>  
  2. struct __type_traits {  
  3.    typedef __true_type    this_dummy_member_must_be_first;  
  4.     //上面这个先不管  
  5.    typedef __false_type   has_trivial_default_constructor;  
  6.    typedef __false_type   has_trivial_copy_constructor;  
  7.    typedef __false_type   has_trivial_assignment_operator;  
  8.    typedef __false_type   has_trivial_destructor;  
  9.    typedef __false_type    is_POD_type;  
  10. };  

STL将所有类型的内嵌型别都定义为__false_type,这事STL给出的保守值，接下来我们会看到针对每一个型别设计的适当的__type_traits的特化版本

 

以下仅列出两个，其他类型的省略：

[cpp]  view plain  copy
 print ?
  1. __STL_TEMPLATE_NULLstruct __type_traits<char> {  
  2.    typedef __true_type   has_trivial_default_constructor;  
  3.    typedef __true_type   has_trivial_copy_constructor;  
  4.    typedef __true_type   has_trivial_assignment_operator;  
  5.    typedef __true_type   has_trivial_destructor;  
  6.    typedef __true_type   is_POD_type;  
  7. };  


[cpp]  view plain  copy
 print ?
  1. //对于原生指针  
  2. template <class T>  
  3. struct__type_traits<T*> {  
  4.    typedef __true_type   has_trivial_default_constructor;  
  5.    typedef __true_type   has_trivial_copy_constructor;  
  6.    typedef __true_type   has_trivial_assignment_operator;  
  7.    typedef __true_type   has_trivial_destructor;  
  8.    typedef __true_type   is_POD_type;  
  9. };  


 

接下来，我们拿几个例子看看uninitialized_fill_n

首先，我们来看看全局函数

[cpp]  view plain  copy
 print ?
  1. template <class ForwardIterator, class Size, class T>  
  2. inline ForwardIteratoruninitialized_fill_n(ForwardIterator first, Size n,  
  3.                                             const T& x) {  
  4.   return __uninitialized_fill_n(first, n, x, value_type(first));  
  5. }  

此函数在关于空间配置器的章节中见到过，用途也不多说了，就是在未初始化的空间内初始化n个x

可以看到，这里我们首先通过value_type（其实就是通过iterator_traits）得到了first类型中的value_type，即first的型别

接着：

[cpp]  view plain  copy
 print ?
  1. template <class ForwardIterator, class Size, class T, class T1>  
  2. inline ForwardIterator__uninitialized_fill_n(ForwardIterator first, Size n,  
  3.                                               const T& x, T1*) {  
  4.   typedef typename __type_traits<T1>::is_POD_type is_POD;  
  5.   return __uninitialized_fill_n_aux(first, n, x, is_POD());  
  6.                                       
  7. }  

再通过__type_traits得到该型别是否是POD类型

[cpp]  view plain  copy
 print ?
  1. //如果正是POD类型的话，只要简单的操作  
  2. template <class ForwardIterator, class Size, class T>  
  3. inline ForwardIterator  
  4. __uninitialized_fill_n_aux(ForwardIteratorfirst, Size n,  
  5.                            const T& x,__true_type) {  
  6.   return fill_n(first, n, x);  
  7. }  
  8. template <class OutputIterator, class Size, class T>  
  9. OutputIteratorfill_n(OutputIterator first, Size n, const T& value) {  
  10.   for ( ; n > 0; --n, ++first)  
  11.     *first = value;  
  12.   return first;  
  13. }  
  14.    

[cpp]  view plain  copy
 print ?
  1. //如果不是POD类型，那么就需要老老实实的一个一个在未初始化的内存中调用构造函数了！  
  2. template <class ForwardIterator, class Size, class T>  
  3. ForwardIterator  
  4. __uninitialized_fill_n_aux(ForwardIteratorfirst, Size n,  
  5.                            const T& x,__false_type) {  
  6.   ForwardIterator cur = first;  
  7.   __STL_TRY {  
  8.     for ( ; n > 0; --n, ++cur)  
  9.       construct(&*cur, x);  
  10.     return cur;  
  11.   }  
  12.   __STL_UNWIND(destroy(first, cur));  
  13. }  


 

再举一个例子，就是copy函数

最近一篇文章就是关于copy函数的笔记，所以详细的部分不再说了。

这里直接放在实例中进行：

[cpp]  view plain  copy
 print ?
  1. class C  
  2. {  
  3. public:  
  4.     //可见，此函数并没有operator= ,即it is a trival assignmentoperator  
  5.     C() :_date(3){}  
  6. private:  
  7.     int _date;  
  8. };  
  9.    
  10. void main()  
  11. {  
  12.     C c[5];  
  13.     vector<C> Cc(c, c + 5);  
  14.     vector<C> Cd(5);  
  15.     copy(Cc.begin(), Cc.end(), Cd.begin());  
  16. }  


回顾之前对copy的学习，我们发现，对于copy内的函数调用的顺序是：

copy() -----  __copy_dispatch(T*, T*)  -----  __copy_t(_false_type)   -----   __copy_d

 

会调用__copy_dispatch(T*,T*)是因为在vector源代码中将iterator定义为类型的指针，并没有做任何处理。

然而为什么会是false_type呢？我们根据类的定义，根据语义，发现的确满足“具有不重要的assignmentoperator”，但返回的结果却依旧是false_type?

学了copy函数后，我们可能会对此感到疑惑，但当我们学过了本章__type_traits的源代码后，我们就可以清楚了知道，STL只对基础的型别进行了偏特化的处理，然而对于其他的型别则一律给予false_type的处理，除非我们自己定义这里类C的__type_traits，如下：

[cpp]  view plain  copy
 print ?
  1. __STL_TEMPLATE_NULLstruct __type_traits<C> {  
  2.    typedef __false_type   has_trivial_default_constructor;  
  3.    typedef __true_type   has_trivial_copy_constructor;  
  4.    typedef __true_type   has_trivial_assignment_operator;  
  5.    typedef __true_type   has_trivial_destructor;  
  6.    typedef __false_type   is_POD_type;  
  7. };  

这样一来，如果再次执行，那么就是true_type了！