STL源码剖析（七）traits机制

矫情吗；* 2023-10-09 09:37 29阅读 0赞

# STL源码剖析（七）traits机制 #

### 文章目录 ###

*  STL源码剖析（七）traits机制
 *   *  一、为什么需要traits机制？
     *  二、iterator traits
     *   *  2.1 iterator traits的定义
         *  2.2 iterator traits相关的函数
     *  三、type traits

## 一、为什么需要traits机制？ ##

traits可以称为萃取机，可以通过它来获取迭代器的一些信息，在STL算法中发挥巨大的作用

如下面为迭代器的traits

template <class Iterator>
    struct iterator_traits {
      typedef typename Iterator::iterator_category iterator_category; //迭代器类型
      typedef typename Iterator::value_type        value_type; //迭代器指向的对象类型
      typedef typename Iterator::difference_type   difference_type; //容器元素间的间隔
      typedef typename Iterator::pointer           pointer; //迭代器指向的对象的指针
      typedef typename Iterator::reference         reference; //迭代器指向的对象的引用
    };

我们可以通过下面操作来获取迭代器的信息

iterator_traits<Iterator>::iterator_category
    iterator_traits<Iterator>::value_type
    iterator_traits<Iterator>::difference_type
    iterator_traits<Iterator>::pointer
    iterator_traits<Iterator>::reference

你可能会好奇，上述的`iterator_traits`貌似没有什么作用，在获取指定信息的时候，只是转而使用了迭代器罢了，那为什么不直接使用迭代器呢？

我们需要明白，上述中可以直接这样子`Iterator::iterator_category`来获取迭代器的信息，但这样子的前提是，迭代器必须是一个`class`，我们才可以在迭代器里面定义类型

不过别忘了，STL允许迭代器是一个原生指针（int\*等类型），这种情况就无法内嵌自定义类型，怎么解决这种情况呢？

通过traits机制作为一个中间层解决，下面来好好看一下STL是如何通过traits机制来解决的

## 二、iterator traits ##

### 2.1 iterator traits的定义 ###

首先看一下泛化的`iterator traits`

这段代码并没有什么特别，只是转而调用迭代器的类型

重要的是，STL对原生指针类型编写了特化版本的`iterator traits`，如下

template <class T>
    struct iterator_traits<T*> {
      typedef random_access_iterator_tag iterator_category;
      typedef T                          value_type;
      typedef ptrdiff_t                  difference_type;
      typedef T*                         pointer;
      typedef T&                         reference;
    };

有了这个，我们可以通过下面操作，来获取原生指针的各种信息

iterator_traits<int*>::iterator_category
    iterator_traits<A*>::iterator_category

然而这样子不够，如果指针为const类型，那么其对应的各种信息也是const类型，如下

iterator_traits<const int*>::value_type //const int

但是这并不是STL的算法所希望的，所以STL还为`iterator traits`实现了一个`const T*`的特化版本

template <class T>
    struct iterator_traits<const T*> {
      typedef random_access_iterator_tag iterator_category;
      typedef T                          value_type;
      typedef ptrdiff_t                  difference_type;
      typedef const T*                   pointer;
      typedef const T&                   reference;
    };

STL的算法中

### 2.2 iterator traits相关的函数 ###

以下这些函数在STL的算法中频繁被使用

**通过iterator traits机制返回迭代器的类型**

template <class Iterator>
    inline typename iterator_traits<Iterator>::iterator_category
    iterator_category(const Iterator&) {
      typedef typename iterator_traits<Iterator>::iterator_category category;
      return category();
    }

**通过iterator traits返回迭代器距离的类型**

template <class Iterator>
    inline typename iterator_traits<Iterator>::difference_type*
    distance_type(const Iterator&) {
      return static_cast<typename iterator_traits<Iterator>::difference_type*>(0);
    }

**通过iterator traits返回迭代器所指向的类型**

template <class Iterator>
    inline typename iterator_traits<Iterator>::value_type*
    value_type(const Iterator&) {
      return static_cast<typename iterator_traits<Iterator>::value_type*>(0);
    }

## 三、type traits ##

traits机制除了应用在迭代器外,STL还将其应用在类型上,用来获取此类型相关的信息

在`type_traits.h`文件中,定义了type\_traits相关的内容

**泛化版本**

struct __true_type {
    };
    
    struct __false_type {
    };
    
    template <class type>
    struct __type_traits {
       typedef __true_type     this_dummy_member_must_be_first;
       typedef __false_type    has_trivial_default_constructor; //是否不重要的默认构造
       typedef __false_type    has_trivial_copy_constructor; //是否不重要的拷贝构造
       typedef __false_type    has_trivial_assignment_operator; //是否不重要的赋值操作
       typedef __false_type    has_trivial_destructor; //是否不重要的析构
       typedef __false_type    is_POD_type; //是否为POD类型
    };

**对char的特化版本**

__STL_TEMPLATE_NULL struct __type_traits<char> {
       typedef __true_type    has_trivial_default_constructor;
       typedef __true_type    has_trivial_copy_constructor;
       typedef __true_type    has_trivial_assignment_operator;
       typedef __true_type    has_trivial_destructor;
       typedef __true_type    is_POD_type;
    };

**对指针的特化版本**

template <class T>
    struct __type_traits<T*> {
       typedef __true_type    has_trivial_default_constructor;
       typedef __true_type    has_trivial_copy_constructor;
       typedef __true_type    has_trivial_assignment_operator;
       typedef __true_type    has_trivial_destructor;
       typedef __true_type    is_POD_type;
    };

还有许多特化版本,这里不一一列出

在STL中,可以通过下面操作来获取该类型的信息

__type_traits<T>::has_trivial_default_constructor
    __type_traits<T>::has_trivial_copy_constructor
    ...

每种类型只有`__true_type`和`__false_type`两种类型

下面举一个STL中应用`__type_traits`的例子,我们先想一下,在析构变量的时候,如果变量不是对象(普通变量或者指针),那么在析构的时候就不需要调用析构函数,下面来看一看STL的析构函数

template <class ForwardIterator, class T>
    inline void __destroy(ForwardIterator first, ForwardIterator last, T*) {
      typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;
      __destroy_aux(first, last, trivial_destructor());
    }

首先`__destroy`会获取此类型的`has_trivial_destructor`,然后再调用`__destroy_aux`函数

`has_trivial_destructor`的意思是:**是否不需要析构**

如果为真,则调用下面函数,可以看到没有任何操作

template <class ForwardIterator> 
    inline void __destroy_aux(ForwardIterator, ForwardIterator, __true_type) {}

否则,调用下面的函数,析构每一个对象

template <class T>
    inline void destroy(T* pointer) {
        pointer->~T();
    }
    
    template <class ForwardIterator>
    inline void
    __destroy_aux(ForwardIterator first, ForwardIterator last, __false_type) {
      for ( ; first < last; ++first)
        destroy(&*first);
    }

本文到此就结束了