C++ STL - list 模拟实现+解析迭代器

__zz11

已于 2022-10-12 17:47:12 修改

阅读量892

点赞数 3

分类专栏： C/C++学习文章标签： c++ 链表数据结构

于 2022-10-12 17:41:51 首次发布

本文链接：https://blog.csdn.net/i777777777777777/article/details/127283890

版权

C/C++学习专栏收录该内容

17 篇文章 3 订阅

订阅专栏

list基本介绍和使用

list - 带头双向循环链表。

对比vector，因为list是由一个个结点连接而成的，致使list
1. 不支持元素的随机访问，即没有operator[]，因为效率低。访问元素front back
2. 没有capacity的概念，内存允许的情况下，可以无限申请节点并扩展
3. 支持push_front pop_front，使得list可以作为queue的适配容器
4. 最大的优势是在任意位置插入删除都可以在O(1)时间完成

学习成员函数见https://cplusplus.com/reference/list/list/

list模拟实现

#ifndef STL_LIST_H
#define STL_LIST_H

#include <cstddef>   // size_t
#include <cassert>
#include <iostream>
#include "reverse_iterator.h"
//using namespace std;
namespace yzl
{
    template<class T>
    struct list_node  // list内部使用的结点类型
    {
    public:
        T _data;
        list_node<T>* _next;
        list_node<T>* _prev;
    public:
        list_node(const T& data = T())  // 结点的默认构造函数
        : _data(data), _next(nullptr), _prev(nullptr)
        { }
//        ~list_node() = default;
//        // 拷贝构造，其实没必要
//        list_node(const list_node<T>& node)
//        : _data(node._data), _next(node._next), _prev(node._prev)  // 浅拷贝
//        { }
//        // 赋值运算符重载，也没必要
//        list_node<T>& operator=(const list_node<T>& node)  // 浅拷贝
//        {
//            _data = node._data;
//            _prev = node._prev;
//            _next = node._next;
//            return *this;
//        }
    };

    // 说真的，只是对结点指针的一个封装罢了，构造函数也是通过一个结点指针即可构造出一个迭代器。
    // 对于迭代器的操作，其实也就是++ -- 然后解引用。目前的操作就是这些，之后再有再补充吧。
    template<class T, class Ref, class Ptr> // T&  T*  or  const T& const T*
    class __list_iterator  // 成员就是一个结点指针
    {
    public:
        typedef list_node<T> Node;  // 这是一个结构体，结点。Node就是一个结点结构体。
        typedef __list_iterator<T, Ref, Ptr> iterator;

        typedef std::bidirectional_iterator_tag iterator_category;
        typedef T value_type;
        typedef Ptr pointer;
        typedef Ref reference;
        typedef ptrdiff_t difference_type;
    public:
        Node* _node;  // 这个迭代器类型有一个数据成员，是结点指针。
    public:
        __list_iterator(Node* node)
        :_node(node)
        { }
        // 这个类型的实例化对象本身不支持解引用操作，operator*赋予了它解引用之后的操作。
        Ref operator*()
        {
            return _node->_data;
        }
        Ptr operator->()
        {
            return &(operator*());
//            return &(_node->_data);
        }
        bool operator!=(const iterator& it)
        {
            return _node != it._node;
        }
        bool operator==(const iterator& it)
        {
            return _node == it._node;
        }
        // 思考一下迭代器++，普通迭代器和const迭代器其实都可以++
        iterator& operator++() // 前置
        {
            _node = _node->_next;
            return *this;
        }
        iterator operator++(int)  // 后置
        {
            iterator tmp = *this;
            this->_node = this->_node->_next;
            return tmp;
        }

        iterator& operator--()
        {
            _node = _node->_prev;
            return *this;
        }
        iterator operator--(int)
        {
            iterator tmp(*this);
            this->_node = this->_node->_prev;
            return tmp;
        }
    };

    // list<int> ls;
    template<class T>
    class list
    {
    private:
        typedef list_node<T> Node;
        Node* _head;    // list_node<int>* _head;

    public:
        // 说真的，关于list的迭代器，你只需要实现begin end这一系列的即可，还要让它的返回值支持++ 解引用操作，这就够了，说真的。
        typedef __list_iterator<T, T&, T*> iterator;   // 这个结构体别名为迭代器，本身是不支持解引用操作的。
        //typedef const __list_iterator<T> const_iterator;  // 你这里const修饰的是迭代器类型，他有结点指针数据成员，const使得结点指针不能改变。
        // 但是根本上，const迭代器是指不能修改*迭代器所指的值。而不是迭代器本身。
        typedef __list_iterator<T, const T&, const T*> const_iterator;

//        typedef __list_reverse_iterator<T, T&, T*> reverse_iterator;
//        typedef __list_reverse_iterator<T, const T&, const T*> const_reverse_iterator;
        typedef __reverse_iterator<__list_iterator<T, T&, T*>, T&, T*> reverse_iterator;
        typedef __reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;
        iterator begin()
        {
            return iterator(_head->_next);
        }
        iterator end()
        {
            return iterator(_head);
        }
        const_iterator begin() const
        {
            return const_iterator(_head->_next);
        }
        const_iterator end() const
        {
            return const_iterator(_head);
        }
        const_iterator cbegin() const
        {
            return const_iterator(_head->_next);
        }
        const_iterator cend() const
        {
            return const_iterator(_head);
        }
        reverse_iterator rbegin()
        {
            return reverse_iterator(end());
        }
        reverse_iterator rend()
        {
            return reverse_iterator(begin());
        }
        const_reverse_iterator rbegin() const
        {
            return const_reverse_iterator(end());
        }
        const_reverse_iterator rend() const
        {
            return const_reverse_iterator(begin());
        }
        const_reverse_iterator crbegin() const
        {
            return const_reverse_iterator(end());
        }
        const_reverse_iterator crend() const
        {
            return const_reverse_iterator(begin());
        }
    public:
        list() {   // list的默认构造函数
            _head = new Node;   // 调用list_node<T>的默认构造函数，头节点里面的data是随机数
            _head->_next = _head;
            _head->_prev = _head;
        }
        ~list()
        {
            clear();
            delete _head;
            _head = nullptr;
        }
        void empty_init()
        {
            _head = new Node;
            _head->_next = _head;
            _head->_prev = _head;
        }
        template<class InputIterator>
        list(InputIterator first, InputIterator last)
        {
            empty_init();
            while(first != last)
            {
                push_back(*first);
                ++first;
            }
        }
        // 拷贝构造函数现代写法
        list(const list<T>& ls)
        {
            empty_init();
            list<T> tmp(ls.begin(), ls.cend());
            this->swap(tmp);
        }
//        list(const list<T>& ls)
//        :_head(new Node)
//        {
//            _head->_next = _head;
//            _head->_prev = _head;
//            for(auto&i:ls)
//            {
//                Node* newnode = new Node(i);
//                Node* tail = _head->_prev;
//                tail->_next = newnode;
//                newnode->_prev = tail;
//                newnode->_next = _head;
//                _head->_prev = newnode;
//            }
//        }
        // ls1 = ls2
        list<T>& operator=(list<T> ls)
        {
            this->swap(ls);
            return *this;
        }
    public:
        void push_back(const T& val)
        {
            Node* newnode = new Node(val);
            Node* tail = _head->_prev;
            tail->_next = newnode;
            newnode->_prev = tail;
            newnode->_next = _head;
            _head->_prev = newnode;
        }
        void push_front(const T& val)
        {
            Node* newnode = new Node(val);
            Node* first = _head->_next;
            _head->_next = newnode;
            newnode->_prev = _head;
            newnode->_next = first;
            first->_prev = newnode;
        }
        iterator insert (iterator position, const T& val)
        {
            Node* cur = position._node;
            Node* prev = cur->_prev;
            Node* newnode = new Node(val);

            prev->_next = newnode;
            newnode->_prev = prev;
            newnode->_next = cur;
            cur->_prev = newnode;

            return iterator(newnode);
        }

        iterator erase(iterator position)
        {
            assert(position._node != _head);

            Node* cur = position._node;
            Node* prev = cur->_prev;
            Node* next = cur->_next;

            prev->_next = next;
            next->_prev = prev;
            delete cur;

            return iterator(next);
        }
        void pop_back()
        {
            assert(size() > 0);
            Node* tail = _head->_prev;
            Node* newtail = tail->_prev;
            newtail->_next = _head;
            _head->_prev = newtail;
            delete tail;
        }
        void pop_front()
        {
            assert(size() > 0);
            Node* front = _head->_next;
            Node* newfront = _head->_next->_next;
            _head->_next = newfront;
            newfront->_prev = _head;
            delete front;
        }
        void show() const
        {
            Node* tmp = _head->_next;
            while(tmp != _head)
            {
                std::cout<<tmp->_data<<" ";
                tmp = tmp->_next;
            }
            std::cout << std::endl;
        }
        void swap(list<T>& ls)
        {
            std::swap(_head, ls._head);
        }
        size_t size() const
        {
            size_t ret = 0;
            Node* tmp = _head->_next;
            while(tmp != _head)
            {
                ++ret;
                tmp = tmp->_next;
            }
            return ret;
        }
        bool empty() const
        {
            return _head->_next == _head;
        }
        T& front()
        {
            assert(size() > 0);
            return _head->_next->_data;
        }
        const T& front() const
        {
            assert(size() > 0);
            return _head->_next->_data;
        }
        T& back()
        {
            assert(size() > 0);
            return _head->_prev->_data;
        }
        const T& back() const
        {
            assert(size() > 0);
            return _head->_prev->_data;
        }
        void clear()  // const不能使用
        {
//            auto it = begin();
//            while(it != end())
//            {
//                it = it = erase(it);
//            }
            Node* it = cbegin()._node;
            while(it != cend()._node)
            {
                Node* prev = it->_prev;
                Node* next = it->_next;
                prev->_next = next;
                next->_prev = prev;
                delete it;
                it = next;
            }
        }
    };
}


#endif //STL_LIST_H

list_node 是结点类，存储data next prev ，很清楚。
而list，只有一个数据成员，就是一个头节点指针 list_node<T>* _head;

先不谈list的迭代器。push_back, pop_back, push_front pop_front size front back等都是带头双向循环链表的基本套路。

list的迭代器：

理解：

我们知道，vector的迭代器是原生指针，这是因为vector底层存储的缘故，原生指针完全符合迭代器的要求。
那么，list是一个双向带头循环链表，由一个个结点组成，结点指针显然不能满足迭代器的要求，因为解引用后是结点实例化对象list_node<T>，而不是数据data。结点指针++也不是下一个结点，因为结点的存储不连续。
不过，基于C++的特性：封装和运算符重载，我们可以把结点指针进行封装，再使用运算符重载重新定义其解引用和++的操作，使其符合迭代器的要求。于是，有了__list_iterator

    template<class T, class Ref, class Ptr> // T&  T*  or  const T& const T*
    class __list_iterator  // 成员就是一个结点指针
    {
    public:
        typedef list_node<T> Node;  // 这是一个结构体，结点。Node就是一个结点结构体。
        typedef __list_iterator<T, Ref, Ptr> iterator;

    public:
        Node* _node;  // 这个迭代器类型有一个数据成员，是结点指针。
    public:
        __list_iterator(Node* node)
        :_node(node)
        { }
        // 这个类型的实例化对象本身不支持解引用操作，operator*赋予了它解引用之后的操作。
        Ref operator*()
        {
            return _node->_data;
        }
        Ptr operator->()
        {
            return &(operator*());
//            return &(_node->_data);
        }
        bool operator!=(const iterator& it)
        {
            return _node != it._node;
        }
        bool operator==(const iterator& it)
        {
            return _node == it._node;
        }
        // 思考一下迭代器++，普通迭代器和const迭代器其实都可以++
        iterator& operator++() // 前置
        {
            _node = _node->_next;
            return *this;
        }
        iterator operator++(int)  // 后置
        {
            iterator tmp = *this;
            this->_node = this->_node->_next;
            return tmp;
        }

        iterator& operator--()
        {
            _node = _node->_prev;
            return *this;
        }
        iterator operator--(int)
        {
            iterator tmp(*this);
            this->_node = this->_node->_prev;
            return tmp;
        }
    };

其实非常简单，这个迭代器类型就是对结点指针的一个封装。和list一样，它只有一个数据成员，即Node* (typedef list_node<T> Node)

然后进行一些运算符重载，比如operator* operator++ operator==，这里也是C++的基础知识，因为结点指针不能直接做迭代器，所以将其封装，但是封装好的类__list_iterator对象本身并不支持解引用 ++ 操作，C++的运算符重载特性使得可以定义这个类对象的某些操作。之后就可以使其像迭代器一样使用，即__list_iterator的对象是list的一个迭代器。

        typedef __list_iterator<T, T&, T*> iterator;   // 这个结构体别名为迭代器，本身是不支持解引用操作的。
        typedef __list_iterator<T, const T&, const T*> const_iterator;

在list内进行如上typedef即可。

const_iterator问题：

        //typedef const __list_iterator<T> const_iterator;  // 你这里const修饰的是迭代器类型，他有结点指针数据成员，const使得结点指针不能改变。

如何区分list的iterator 和 const_iterator是一个问题，首先我们需要明确const_iterator需要什么特殊性质：解引用后的值是const的，且是引用性质的。迭代器本身可以++ --。如上代码是最初我想的一个错误的实现，挺愚蠢的。const_iterator 并不是 const __list_iterator，这里的const __list_iterator使得这个迭代器存储的Node*不能改变，也就是迭代器不能++ --。这是错误的。

根本上我们需要控制的是迭代器__list_iterator类对象operator* operator->的返回值，普通迭代器返回普通引用，const迭代器返回const &，这里通过模板参数即可实现。

通过在list中实例化时模板参数不同，从而确定operator*的返回值。

    template<class T, class Ref, class Ptr> // T&  T*  or  const T& const T*
    class __list_iterator  // 成员就是一个结点指针

        typedef __list_iterator<T, T&, T*> iterator;   // 这个结构体别名为迭代器，本身是不支持解引用操作的。
        typedef __list_iterator<T, const T&, const T*> const_iterator;

基于模板的知识我们知道，模板的参数不同，则实际上是完全不同的两个类。上方的iterator 和 const_iterator大部分都是一样的，只有operator* 和 operator->的返回值不同，他们都可以完成operator++ opeator--操作。

list迭代器失效问题：

迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

void TestListIterator1()
{
 int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
 list<int> l(array, array+sizeof(array)/sizeof(array[0]));
 auto it = l.begin();
 while (it != l.end())
 {
 // erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给
其赋值
 l.erase(it); 
 ++it;
 }
}
// 改正
void TestListIterator()
{
 int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
 list<int> l(array, array+sizeof(array)/sizeof(array[0]));
 auto it = l.begin();
 while (it != l.end())
 {
 l.erase(it++); // it = l.erase(it);
 }
}

list的反向迭代器

STL的反向迭代器实际上运用的是适配器设计模式。

理解：

首先，还是要明白反向迭代器的操作，再来说如何实现它更方便。
反向迭代器，无非就是++是往前，--是往后。同样支持解引用操作和 == != 判断。

那么，感觉正向和反向迭代器的操作并没有太大变化，无非++ -- 的方向不同。故我们可以基于正向迭代器的操作，进行封装，然后设计出反向迭代器。（这里在学完stack queue priority_queue之后再学会更好理解一点）

reverse_iterator.h

namespace yzl
{
    template <class Iterator, class Ref, class Ptr>  // 没必要传T
    class __reverse_iterator
    {
        // 反向迭代器
    public:
        typedef __reverse_iterator<Iterator, Ref, Ptr> reverse_iterator;
    public:
        __reverse_iterator(const Iterator& _it)  // 用一个正向迭代器去构造反向迭代器
        :it(_it)
        {}
        Ref operator*() // 反向迭代器的解引用操作和正向的一样
        {
//            Iterator tmp = --it;
//            ++it;
//            return *tmp;
            auto tmp = it;
            --tmp;
            return *tmp;
        }
        Ptr operator->()
        {
            return &(this->operator*());
        }
        reverse_iterator& operator++()  // 前置++，迭代器向后一步即可。
        {
            --it;   // 调用构造函数中传来的迭代器的operator--()
            return *this;
        }
        reverse_iterator operator++(int)
        {
            reverse_iterator ret = *this;
            --it;
            return ret;
        }
        reverse_iterator& operator--()
        {
            ++it;
            return *this;
        }
        reverse_iterator operator--(int)
        {
            auto ret = *this;
            ++it;
            return ret;
        }
        bool operator==(const reverse_iterator& rit)
        {
            return it == rit.it;
        }
        bool operator!=(const reverse_iterator& rit)
        {
            return it != rit.it;
        }
    private:
        Iterator it;
    };
}

模板参数Iterator就是传来的正向迭代器，只有一个数据成员，即一个正向迭代器it，因为正向迭代器已经支持了* -> ++ -- == !=操作，所以上述实现都是基于这个基础来完成的。

因为我们仅凭传来的一个正向迭代器无法直接得出其保存的元素类型，即T的类型（不考虑类型萃取）。所以增加了两个类型参数Ref Ptr，用于指明operator* operator->的返回值

这个不仅适用于list，vector也同样适用。因为vector的正向迭代器（原生指针）支持那些操作。所以直接利用适配器设计模式进行封装即可得到反向迭代器。

        typedef __reverse_iterator<__list_iterator<T, T&, T*>, T&, T*> reverse_iterator;
        typedef __reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;

在list内进行如上typedef并非必要操作，而是这样在下面rbegin rend处更方便...

反向迭代器的operator*实现：

        Ref operator*() // 反向迭代器的解引用操作和正向的一样
        {
//            Iterator tmp = --it;
//            ++it;
//            return *tmp;
            auto tmp = it;
            --tmp;
            return *tmp;
        }

这里的operator*并不是直接获取此正向迭代器所指元素，而是其前一个元素。这样做不是必须的。

如上图，这样做仅仅为了让begin 和 rend对应上，end和rbegin对应上。
如果operator*是直接返回正向迭代器所值元素，则rbegin指向7，rend指向1前面的那个位置。
同理，在list中，则rbegin()指向最后一个元素，rend指向头节点。

operator->()

我们知道，迭代器是一个类似指针的东西，->运算符一般是用于自定义类型对象指针使用->直接获取其某个数据成员。比如Date* p = &d1; cout << p->year << endl; 那么迭代器重载->是为什么呢？

迭代器指向元素类型不确定，比如int，或者一个Date。这要看容器存储的什么元素类型。迭代器重载->就是为了当迭代器指向自定义类型时使用->可以直接获取其数据成员比如：

std::list<Date> ls;
ls.push_back(Date(2001,1,1));
ls.push_back(Date(2002,1,1));
std::list<date>::iterator it = ls.begin();
cout << it->year << endl;

这里应该输出2001，这里it->year就调用了迭代器的operator-> 返回值是元素指针即Date*。
那么 it->的返回值是一个Date*，又是如何直接和year连接起来呢？实际上这里省略了一个->应该是it->->year;

void test11()
{
    yzl::list<Date> ls;
    ls.push_back(Date(2001,1,1));
    ls.push_back(Date(2002,2,2));
    yzl::list<Date>::reverse_iterator rit = ls.rbegin();
    
    cout<<rit.operator->()->year<<endl;
    cout<<rit->year<<endl;
}

结果2002