STL源码剖析--迭代器（转）

时间  2019-11-20
标签 stl 源码 剖析 迭代 繁體版
原文   原文链接

1、为何须要traits编程技术

 

       前面说了不少关于traits的光荣事迹，可是却一直没有介绍traits到底是个什么东西，到底是用来干什么的？traits在英文解释中就是特性，下面将会引入traits技术的做用，一步一步地揭开其神秘的面纱。算法

 

1.1 内嵌类型声明

 

 

1.1.1 以迭代器所指对象的类型声明局部变量

 

       下面是一个以迭代器为模板形参的函数模板：编程

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. template<typename Iterator>  
  2. void func(Iterator iter)  
  3. {  
  4.     //函数体  
  5. }  
  
template<typename Iterator>
void func(Iterator iter)
{
    //函数体
}

       假如如今算法中须要声明一个变量，而变量的类型是迭代器所指对象的类型，应该怎么处理呢？dom

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. template<typename Iterator>  
  2. void func(Iterator iter)  
  3. {  
  4.     *Iterator var;//这样定义变量能够吗？  
  5. }  
  
template<typename Iterator>
void func(Iterator iter)
{
    *Iterator var;//这样定义变量能够吗？
}

       上面的代码是不能够经过编译的，虽然C++支持sizeof()，可是并不支持typeof()，就算是用到RTTI性质中的typeid()，获取到的也仅仅是类型的名字，所以不能直接用来声明变量。此时能够利用函数模板的参数类型推导机制解决问题，例如：函数

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. template<typename Iterator, typename T>  
  2. void func_impl(Iterator iter, T t)  
  3. {  
  4.     T temp;//这里就解决了问题  
  5.     //这里作本来func()的工做  
  6. }  
  7.   
  8. template<typename Iterator>  
  9. void func(Iterator iter)  
  10. {  
  11.     func_impl(iter, *iter);//func的工做所有都移到func_impl里面了  
  12. }  
  13.   
  14. int main(int argc, const char *argv[])  
  15. {  
  16.     int i;  
  17.     func(&i);  
  18. }  
  
template<typename Iterator, typename T>
void func_impl(Iterator iter, T t)
{
    T temp;//这里就解决了问题
    //这里作本来func()的工做
}

template<typename Iterator>
void func(Iterator iter)
{
    func_impl(iter, *iter);//func的工做所有都移到func_impl里面了
}

int main(int argc, const char *argv[])
{
    int i;
    func(&i);
}

       函数func做为对外接口，实际的操做却由函数func_impl执行，经过函数func_impl的参数类型推导，获取到Iterator指向对象的类型T，从而解决了问题。学习

 

1.1.2 以迭代器所指对象的类型声明返回类型

 

       如今经过函数模板的参数类型推导解决了函数体内声明变量的问题，但问题又来了，若是须要返回类型是迭代器所指对象的类型又能够怎样作呢？spa

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. template<typename Iterator>  
  2. (*Iterator) func(Iterator iter)  
  3. {  
  4.     //这样定义返回类型能够吗？  
  5. }  
  
template<typename Iterator>
(*Iterator) func(Iterator iter)
{
    //这样定义返回类型能够吗？
}

       在这种状况下，模板的参数类型推导机制也无能为力了，由于它只能推导参数，并不能推导函数的返回类型。STL解决这种问题的办法就是内嵌类型声明，即在迭代器内部添加一种“特性”，经过这种“特性”，算法能够很容易地获知迭代器所指对象的类型，请看下面的代码：.net

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. template<typename T>  
  2. class Iterator  
  3. {  
  4. public:  
  5.     typedef T value_type;//内嵌类型声明  
  6.     Iterator(T *p = 0) : m_ptr(p) {}  
  7.     T& operator*() const { return *m_ptr;}  
  8.     //...  
  9.   
  10. private:  
  11.     T *m_ptr;  
  12. };  
  13.   
  14. template<typename Iterator>  
  15. typename Iterator::value_type  //以迭代器所指对象的类型做为返回类型，长度有点吓人！！！  
  16. func(Iterator iter)  
  17. {  
  18.     return *iter;  
  19. }  
  20.   
  21. int main(int argc, const char *argv[])  
  22. {  
  23.     Iterator<int> iter(new int(10));  
  24.     cout<<func(iter)<<endl;  //输出：10  
  25. }  
  
template<typename T>
class Iterator
{
public:
    typedef T value_type;//内嵌类型声明
    Iterator(T *p = 0) : m_ptr(p) {}
    T& operator*() const { return *m_ptr;}
    //...

private:
    T *m_ptr;
};

template<typename Iterator>
typename Iterator::value_type  //以迭代器所指对象的类型做为返回类型，长度有点吓人！！！
func(Iterator iter)
{
    return *iter;
}

int main(int argc, const char *argv[])
{
    Iterator<int> iter(new int(10));
    cout<<func(iter)<<endl;  //输出：10
}

       函数func()的返回类型前面必须加上关键词typename，缘由在本人以前写的“C++模板学习”中也解释过，由于T是一个template参数，编译器在编译实例化func以前，对T一无所知，就是说，编译器并不知道Iterator<T>::value_type是一个类型，或者是一个静态成员函数，仍是一个静态数据成员，关键词typename的做用在于告诉编译器这是一个类型，这样才能顺利经过编译。设计

 

1.2 原生指针也是一种迭代器

 

       以前在介绍迭代器的分类之时说过，原生指针也是一种迭代器，此时问题就来了，原生指针并非一种类类型，它是没法定义内嵌类型的。所以，上面的内嵌类型实现还不能彻底解决问题，那可不能够针对原生指针作特殊化的处理呢？答案是确定的，利用模板偏特化就能够作到了。指针

       《泛型思惟》一书对模板偏特化的定义是：code

        针对template参数更进一步的条件限制所设计出来的一个特化版本。

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. //这个泛型版本容许T为任何类型  
  2. template<typename T>  
  3. class C  
  4. {   
  5.     //...  
  6. };    
  
//这个泛型版本容许T为任何类型
template<typename T>
class C
{ 
    //...
};

       咱们很容易接受上面的类模板有一个形式以下的偏特化版本：

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. template<typename T>  
  2. class C<T*>   
  3. {  
  4.     //...   
  5. };  
  
template<typename T>
class C<T*> 
{
    //... 
};

       这个特化版本仅适用于T为原生指针的状况，”T为原生指针”就是“T为任何类型”的一个更进一步的条件限制。那如何利用模板偏特化解决原生指针不能内嵌类型的问题呢？下面介绍的iterator_traits就是关键了。

 

2、迭代器萃取机--iterator_traits

 

 

2.1 原生指针并非一种类类型

 

       STL里面使用iterator_traits这个结构来专门“萃取”迭代器的特性，前面代码中提到的value_type就是迭代器的特性之一：

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. template<typename Iterator>  
  2. struct iterator_traits  
  3. {  
  4.     typedef typename Iterator::value_type value_type;  
  5. };  
  
template<typename Iterator>
struct iterator_traits
{
    typedef typename Iterator::value_type value_type;
};

       若是Iterator有定义value_type，那么经过iterator_traits做用以后，获得的value_type就是Iterator::value_type，比较以前写的版本和经iterator_traits做用后的版本：

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. template<typename Iterator>  
  2. typename Iterator::value_type  //这行是返回类型  
  3. func(Iterator iter)  
  4. {  
  5.     return *iter;  
  6. }  
  7.   
  8. //经过iterator_traits做用后的版本  
  9. template<typename Iterator>  
  10. typename iterator_traits<Iterator>::value_type  //这行是返回类型  
  11. func(Iterator iter)  
  12. {   
  13.     return *iter;  
  14. }  
  
template<typename Iterator>
typename Iterator::value_type  //这行是返回类型
func(Iterator iter)
{
    return *iter;
}

//经过iterator_traits做用后的版本
template<typename Iterator>
typename iterator_traits<Iterator>::value_type  //这行是返回类型
func(Iterator iter)
{ 
    return *iter;
}

       从长度上看，好像须要敲的代码更多了，为何要这么麻烦加上一层间接层呢？因为原生指针也是一种迭代器，并且不是一种类类型，所以原生指针并不能定义内嵌类型。这里经过实现iterator_traits的一个偏特化版本就能够解决这个问题了，具体的实现以下：

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. //iterator_traits的偏特化版本，针对迭代器是个原生指针的状况  
  2. template<typename T>  
  3. struct iterator_traits<T*>  
  4. {  
  5.     typedef T value_type;  
  6. };  
  
//iterator_traits的偏特化版本，针对迭代器是个原生指针的状况
template<typename T>
struct iterator_traits<T*>
{
    typedef T value_type;
};

       你们在进行函数重载的时候，应该都曾遇到过如下的状况：

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. //函数版本一  
  2. void func(int *ptr)  
  3. {   
  4.     //...  
  5. }  
  6.   
  7. //函数版本二  
  8. void func(const int *ptr)  
  9. {   
  10.     //...  
  11. }  
  
//函数版本一
void func(int *ptr)
{ 
    //...
}

//函数版本二
void func(const int *ptr)
{ 
    //...
}

       以上两个函数虽然函数、形参个数和位置都同样，但它们不是同一个函数，而是函数重载的一种状况，也就是说函数形参的const和非const版本是不同的，在函数版本一里面，能够修改指针ptr指向的数据，可是在函数版本二里面却不能够，由于传入的指针ptr是一个const指针。由此能够联想到，当将一个const指针做为模板形参传给前面声明的偏特化版本的iterator_traits会有发生什么状况呢？

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. iterator_traits<const int*>::value_type  //得到的value_type是const int，并非int  
  
iterator_traits<const int*>::value_type  //得到的value_type是const int，并非int

       当咱们想用iterator_traits萃取出value_type并声明一个临时变量时，却发现声明的变量是const类型，并不能进行赋值，这违背了咱们的用意。咱们须要一种方法区别const和非const才能避免这种误会的发生，答案很简单，只要另外再设计一个iterator_traits偏特化版本就能够了：

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. template<typename T>  
  2. struct iterator_traits<const T*>  
  3. {  
  4.     typedef T value_type;  
  5. }  
  
template<typename T>
struct iterator_traits<const T*>
{
    typedef T value_type;
}

       如今，不管是自定义的迭代器，仍是原生指针int*或者是const int*，均可以经过iterator_traits获取到正确的value_type。

 

2.2 iterator_traits中定义的类型

 

       STL根据经验，定义了迭代器最经常使用到的五种类型：value_type、difference_type、pointer、reference、iterator_category，任何开发者若是想将本身开发的容器与STL结合在一块儿，就必定要为本身开发的容器的迭代器定义这五种类型，这样均可以经过统一接口iterator_traits萃取出相应的类型，下面列出STL中iterator_traits的完整定义：

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. tempalte<typename I>  
  2. struct iterator_traits  
  3. {  
  4.     typedef typename I::iterator_category iterator_category;  
  5.     typedef typename I::value_type value_type;  
  6.     typedef typeanme I:difference_type difference_type;  
  7.     typedef typename I::pointer pointer;  
  8.     typedef typename I::reference reference;  
  9. };  
  
tempalte<typename I>
struct iterator_traits
{
    typedef typename I::iterator_category iterator_category;
    typedef typename I::value_type value_type;
    typedef typeanme I:difference_type difference_type;
    typedef typename I::pointer pointer;
    typedef typename I::reference reference;
};

       下面会分别介绍一下这五种类型：

(1) 迭代器类型之一：value_type
       value_type就是指迭代器所指对象的类型，例如，原生指针也是一种迭代器，对于原生指针int*，int即为指针所指对象的类型，也就是所谓的value_type。

(2) 迭代器类型之二：difference_type
       difference_type用来表示两个迭代器之间的距离，例如：

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. int array[5] = {1, 2, 3, 4, 5};  
  2. int *ptr1 = array + 1;//指向2  
  3. int *ptr2 = array + 3;//指向4  
  4. ptrdiff_t distance = ptr2 - ptr1;//结果即为difference_type  
  
int array[5] = {1, 2, 3, 4, 5};
int *ptr1 = array + 1;//指向2
int *ptr2 = array + 3;//指向4
ptrdiff_t distance = ptr2 - ptr1;//结果即为difference_type

       上面代码中，指针ptr2与ptr1相减的结果的类型就是difference_type，对于原生指针，STL以C++内建的ptrdiff_t做为原生指针的difference_type。

(3) 迭代器类型之三：reference_type

       reference_type是指迭代器所指对象的类型的引用，reference_type通常用在迭代器的*运算符重载上，若是value_type是T，那么对应的reference_type就是T&；若是value_type是const T，那么对应的reference_type就是const T&。

(4) 迭代器类型之四：pointer

       pointer就是指迭代器所指的对象，也就是相应的指针，对于指针来讲，最经常使用的功能就是operator*和operator->两个运算符。所以，迭代器须要对这两个运算符进行相应的重载工做：

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. T& operator*() const { return *ptr; } // T& is reference type  
  2. T* operator->() const { return ptr; } // T* is pointer type  
  
T& operator*() const { return *ptr; } // T& is reference type
T* operator->() const { return ptr; } // T* is pointer type

(5) 迭代器类型之五：iterator_category

       iterator_category的做用是标识迭代器的移动特性和能够对迭代器执行的操做，从iterator_category上，可将迭代器分为Input Iterator、Output Iterator、Forward Iterator、Bidirectional Iterator、Random Access Iterator五类，具体为何要这样分类，简单来讲，就是为了尽量地提升效率，这也是STL的宗旨之一。具体的状况已经在本人的“《STL源码剖析》学习之迭代器”中详细介绍过，这里就不在多说了。

 

2.3 iterator_traits完整定义

 

       为了保证iterator_traits能够正常工做，STL提供了一个iterator类，全部自定义的迭代器都必须继承自它，这样才能保证这些自定义的迭代器能够顺利地狱其它STL组件进行协做，iterator类具体定义以下：

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. template<typename Category,  
  2.          typename T,  
  3.          typename Distance = ptrdiff_t,  
  4.          typename Pointer = T*,  
  5.          typename Reference = T&>  
  6. struct iterator  
  7. {  
  8.     typedef Category iterator_category;  
  9.     typedef T value_type;  
  10.     typedef Distance difference_type;  
  11.     typedef Pointer pointer;  
  12.     typedef Reference reference;  
  13. };  
  
template<typename Category,
         typename T,
         typename Distance = ptrdiff_t,
         typename Pointer = T*,
         typename Reference = T&>
struct iterator
{
    typedef Category iterator_category;
    typedef T value_type;
    typedef Distance difference_type;
    typedef Pointer pointer;
    typedef Reference reference;
};

       类iterator不包含任何成员变量，只有类型的定义，所以不会增长额外的负担。因为后面三个类型都有默认值，在继承它的时候，只须要提供前两个参数就能够了，如：

[cpp] view plain copy
 
print?在CODE上查看代码片派生到个人代码片
  1. template <typename T>  
  2. class ListIter : public std::iterator<std::forward_iterator_tag, T>  
  3. {  
  4.     //...  
  5. }  
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程