• 迭代器的封装与反向迭代器


    一、反向迭代器

    在list模拟实现的过程中,第一次接触了迭代器的封装,将list的指针封装成了一个新的类型,并且以迭代器的基本功能对其进行了运算符重载

    反向迭代器是对正向迭代器的封装,并且体现了泛型编程的思想,任意类型的双向迭代器都可以直接复用反向迭代器

    本章将把两个迭代器的实现放在一起比对,更好的体会迭代器的封装

    二、list正向迭代器的模拟实现

    详解可以看list模拟实现那一章节,这里仅提供一份代码用于对照反向迭代器

    1. template<class T,class Ref,class Ptr>
    2. struct __list_iterator
    3. {
    4. typedef list_node node;
    5. typedef __list_iterator self;
    6. node* _pnode;
    7. __list_iterator(node* p)
    8. :_pnode(p)
    9. {}
    10. self& operator++()
    11. {
    12. _pnode = _pnode->_next;
    13. return *this;
    14. }
    15. self& operator--()
    16. {
    17. _pnode = _pnode->_prev;
    18. return *this;
    19. }
    20. self operator++(int)
    21. {
    22. self tmp(_pnode);
    23. _pnode = _pnode->_next;
    24. return tmp;
    25. }
    26. self operator--(int)
    27. {
    28. self tmp(_pnode);
    29. _pnode = _pnode->_prev;
    30. return tmp;
    31. }
    32. Ref operator*()
    33. {
    34. return _pnode->_data;
    35. }
    36. Ptr operator->()
    37. {
    38. return &(_pnode->_data);
    39. }
    40. bool operator!=(const self& p)
    41. {
    42. return _pnode != p._pnode;
    43. }
    44. bool operator==(const self& p)
    45. {
    46. return _pnode == p._pnode;
    47. }
    48. };

    三、反向迭代器的封装实现(双向迭代器)

    反向迭代器的实现是对正向迭代器的封装

    1.成员及其初始化

    1. template<class Iterator,class Ref,class Ptr>
    2. struct ReserveIterator
    3. {
    4. typedef ReserveIterator self;//重命名方便使用
    5. Iterator _it;//成员变量
    6. ReserveIterator(Iterator it)
    7. :_it(it)
    8. {}
    9. }

    2.基本功能的重载

    (1) ++ 和 --

    在反向迭代器的概念中,反向迭代器++,就是正向迭代器--

    1. self& operator++()
    2. {
    3. _it--;
    4. return *this;
    5. }
    6. self& operator--()
    7. {
    8. _it++;
    9. return *this;
    10. }
    11. //前置++和--
    12. self operator++(int)
    13. {
    14. self tmp(*this);
    15. _it--;
    16. return tmp;
    17. }
    18. self operator--(int)
    19. {
    20. self tmp(*this);
    21. _it++;
    22. return tmp;
    23. }

    (2) != 和 ==

    1. bool operator!=(const self& s)
    2. {
    3. return _it != s._it;
    4. }
    5. bool operator==(const self& s)
    6. {
    7. return _it == s._it;
    8. }

    (3) -> 和 *

    在实现operator*()之前,要先理解底层,在stl库内的实现,为了让begin()和rend(),所在的物理空间上对称,但在使用的角度上来看,并不对称,为了使其对称,且不影响使用,对*和->的实现作出了调整,解引用返回的是其前一个的位置

    1. Ref operator*()
    2. {
    3. Iterator tmp(_it);
    4. _it--;
    5. return *tmp;
    6. }
    7. Ptr operator->()
    8. {
    9. Iterator tmp(_it);
    10. _it--;
    11. return &(*_it);
    12. }

    3.定义部分

    1. typedef __list_iterator iterator;
    2. typedef __list_iteratorconst T&, const T*> con_iterator;
    3. typedef ReverseIterator reverse_iterator;
    4. typedef ReverseIteratorconst T&,const T*> con_reverse_iterator;
    5. iterator begin()
    6. {
    7. return iterator(_head->_next);
    8. }
    9. iterator end()
    10. {
    11. return iterator(_head);
    12. }
    13. con_iterator begin()const
    14. {
    15. return con_iterator(_head->_next);
    16. }
    17. con_iterator end()const
    18. {
    19. return con_iterator(_head);
    20. }
    21. reverse_iterator rbegin()
    22. {
    23. return reverse_iterator(end());
    24. }
    25. reverse_iterator rend()
    26. {
    27. return reverse_iterator(begin());
    28. }

    总结

    本章整理了关于反向迭代器的相关内容,以及模拟实现

  • 相关阅读:
    Microservices communication
    西门子S7-200SMART常见通讯问题解答
    esp8266用arduino连上阿里云(图文操作,100%成功)
    什么是GNSS模拟器及其应用?
    《从零开始学架构》读书笔记(上)
    新课程标准培养学生“高考物理关键能力”的实践研究课题文献综述
    PLC直线插补
    Nginx补充部分--IO模型
    高防CDN有什么作用?
    伪静态web.config常见规则写法与参数介绍说明
  • 原文地址:https://blog.csdn.net/china_chk/article/details/134037763