【C++】list模拟实现

最新推荐文章于 2023-09-10 20:28:56 发布
最新推荐文章于 2023-09-10 20:28:56 发布
阅读量709 收藏 12
点赞数 17
分类专栏： C++ 文章标签： c++ list 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53943591/article/details/131616463
版权

🚀 作者简介：一名在后端领域学习，并渴望能够学有所成的追梦人。
🚁 个人主页：不 良
🔥 系列专栏：🛸C++  🛹Linux
📕 学习格言：博观而约取，厚积而薄发
🌹 欢迎进来的小伙伴，如果小伙伴们在学习的过程中，发现有需要纠正的地方，烦请指正，希望能够与诸君一同成长！ 🌹

文章目录

定义结点类

list相当于带头节点的双向链表，我们定义节点时要用类模板参数，同时定义_next、_prev指针和数据_data，使用struct定义类，因为节点类要能够被访问，而struct的默认访问权限就是public；构造函数缺省值要使用匿名对象，保证无论是自定义类型还是内置类型都能够构造成功。

//定义节点
template<class T>
struct list_node {
    list_node<T>* _next;
    list_node<T>* _prev;
    T _data;
    //节点构造函数,缺省值使用匿名对象
    list_node(const T& x = T())
        :_next(nullptr)
        ,_prev(nullptr)
        ,_data(x)
        {
        }
};

lis类的成员变量和构造函数

list是带头节点的双向链表，所以成员变量我们只需要定义一个头结点_head，构造函数就是让头节点指向自己。

注意成员变量类型为类名 + 模板参数。

template<class T>
class list {
    typedef list_node<T> node;
    public:
    list()
    {
        _head = new node;
        _head->_prev = _head;
        _head->_next = _head;
    }
    private:
    node* _head;
};

list的迭代器

vector和string的底层物理空间是连续的，我们可以通过指针的++或–来移动找到对应的元素，然而list的底层物理空间是不连续的，所以模拟实现list迭代器时，如果使用++或 --操作，++或 --的只是一个指针，并不能找到对应的位置。我们可以封装一个list迭代器类，实际上就是对结点指针进行封装，将各种运算符进行重载，使得在list类中能够像vector和string一样能够直接使用迭代器，而不用关心底层实现。

//迭代器类
template<class T>
struct __list_iterator {
    typedef list_node<T> node;
    typedef __list_iterator<T> self;
    node* _node;
    //构造一个迭代器，用结点的指针构造
    __list_iterator(node* n)
        :_node(n)
        {

        }
    T& operator*()
    {
        return _node->_data;
    }
    self& operator++()
    {
        _node = _node->_next;
        return *this;
    }
    //不相等比较的就是结点的指针
    bool operator!=(const self& s)
    {
        return _node != s._node;
    }
};

测试：

void test_list1()
{
    list<int> l1;
    l1.push_back(1);
    l1.push_back(1);
    l1.push_back(1);
    l1.push_back(1);
    list<int>::iterator it = l1.begin();
    while (it != l1.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
}

在上面的测试代码中list<int>::iterator it = l1.begin();这句话调用了拷贝构造，因为我们没有实现所以调用的就是编译器自动生成的即浅拷贝，这里之所以能够使用浅拷贝是因为迭代器类中没有写析构函数，而且不需要释放结点（结点的指针不属于迭代器，仅仅是使用list结点，没有拥有list结点，没有权利释放list的对象，结点的析构交给链表。迭代器只是一个工具）。

完善一些后置++、后置–之后的代码：

//迭代器类
template<class T>
struct __list_iterator {
    typedef list_node<T> node;
    typedef __list_iterator<T> self;
    node* _node;
    //构造一个迭代器，用结点的指针构造
    __list_iterator(node* n)
        :_node(n)
        {

        }
    //重载解引用操作符*
    T& operator*()
    {
        return _node->_data;
    }
    //重载前置++
    self& operator++()
    {
        _node = _node->_next;
        return *this;
    }
    //重载后置++
    self operator++(int)
    {
        self tmp(*this);
        _node = _node->_next;
        return tmp;
    }
    //重载前置--
    self& operator--()
    {
        _node = _node->_prev;
        return *this;
    }
    //重载后置--
    self operator--(int)
    {
        self tmp(*this);
        _node = _node->_prev;
        return tmp;
    }
    //不相等比较的就是结点的指针
    bool operator!=(const self& s)
    {
        return _node != s._node;
    }
    bool operator==(const self& s)
    {
        return _node == s._node;
    }
};

当我们实现上述代码之后我们就可以在list类中实现begin和end函数：

iterator begin()
{
    return iterator(_head->_next);
}
iterator end()
{
    return iterator(_head);
}

当我们想要接收const对象时就需要先实现const_iterator：如下的代码

void print_list(const list<int>& l1)
{
    list<int>::iterator it = l1.begin();
    while (it != l1.end())
    {
        (*it) *= 2;
        cout << *it << " ";
        ++it;
    }
    cout << endl;
}

我们在list类中实现下面的代码中编译能够通过：

iterator begin() const
{
    return iterator(_head->_next);
}
iterator end() const
{
    return iterator(_head);
}

但是为什么使用const修饰之后还能构造普通迭代器？这里的const修饰的是*this，也就是this指针指向的内容，但是这里this指针指向的内容还是一个指针，修饰的是指针本身即修饰的_head不能被改变，并不是_head指向的内容，指针本身不能改变，但是可以拷贝给别人，也就是说可以将这个指针传到迭代器类中。

虽然上述代码可以通过编译了，但是并不能达到我们想要的效果，仍然能够改变list中的元素值，为什么呢？因为构造出来的迭代器是普通迭代器，可读可修改。

库中const对象调用的是const函数，返回的是const迭代器。

库中函数声明：

     	iterator begin();
const_iterator begin() const;

const迭代器和普通迭代器的区别是：const迭代器本身可以修改，const迭代器指向的内容不可以被修改。

那我们可不可以用下面这种方式定义const迭代器呢？

typedef __list_iterator<T> iterator;   //T*
typedef const iterator const_iterator;  // T* const，而我们想要的是迭代器内容不能被修改，const T*

不可以，普通迭代器对标的是指针即T*，而const加在iterator前面保护迭代器本身不能被修改相当于保护指针不被修改即 T* const，而我们想要的是迭代器指向的内容不能被修改即const T*。

那我们想实现const迭代器应该怎么实现呢？很简单，只需要将普通迭代器代码稍加修改：

//const迭代器类
template<class T>
struct __list_const_iterator {
    typedef list_node<T> node;
    typedef __list_const_iterator<T> self;
    node* _node;
    //构造一个迭代器，用结点的指针构造
    __list_const_iterator(node* n)
        :_node(n)
        {

        }
    //重载解引用操作符*
    const T& operator*()
    {
        return _node->_data;
    }
    //重载前置++
    self& operator++()
    {
        _node = _node->_next;
        return *this;
    }
    //重载后置++
    self operator++(int)
    {
        self tmp(*this);
        _node = _node->_next;
        return tmp;
    }
    //重载前置--
    self& operator--()
    {
        _node = _node->_prev;
        return *this;
    }
    //重载后置--
    self operator--(int)
    {
        self tmp(*this);
        _node = _node->_prev;
        return tmp;
    }
    //不相等比较的就是结点的指针
    bool operator!=(const self& s)
    {
        return _node != s._node;
    }
    bool operator==(const self& s)
    {
        return _node == s._node;
    }
};

再将list类中的begin函数和end函数重载：

const_iterator begin() const
{
    return const_iterator(_head->_next);
}
const_iterator end() const
{
    return const_iterator(_head);
}

此时我们再将print_list代码修改如下即可实现我们想要的功能：

void print_list(const list<int>& l1)
{
    list<int>::const_iterator it = l1.begin();
    while (it != l1.end())
    {
        //(*it) *= 2;
        cout << *it << " ";
        ++it;
    }
    cout << endl;
}

观察发现，const迭代器类和普通迭代器类中只有*重载运算符函数的返回值不一样，我们可以通过增加一个模板参数来控制返回值：

//迭代器类
template<class T,class Ref> //增加一个模板参数
struct __list_iterator {
    typedef list_node<T> node;
    typedef __list_iterator<T,Ref> self;
    node* _node;
    //构造一个迭代器，用结点的指针构造
    __list_iterator(node* n)
        :_node(n)
        {
        }
    //重载解引用操作符*
    Ref operator*()
    {
        return _node->_data;
    }
};

然后在list类中通过模板参数控制返回值：

template<class T>
	class list {
		//将节点类型重命名为node
		typedef list_node<T> node;
	public:
		//将迭代器类重命名为iterator
		typedef __list_iterator<T,T&> iterator;
		typedef __list_iterator<T,const T&> const_iterator;
	private:
		node* _head;
	};

image-20230703212948556

模板参数传引用或者传指针都可以，模板参数不同类型也就不同。

库里面的list迭代器类中一共有3个模板参数：

template<class T,class Ref,class Ptr>

我们要知道：

1.迭代器要么就是原生指针；

2.迭代器要么就是自定义类型对原生指针的封装，模拟指针的行为（因为node*本身的++不符合需求，不是连续的空间）。

我们还需要重载一个->，自定义类型的指针要用->，内置类型用解引用*就可以。

如下面的测试代码：一般的类最好都将默认构造加上，并且给上缺省值。

struct AA {
    int _a1;
    int _a2;
    AA(int a1 = 0, int a2 = 0)
        :_a1(a1)
        ,_a2(a2)
        {

        }
}; 
void test_list2()
{
    list<AA> l1;
    l1.push_back(AA(1, 2));
    l1.push_back(AA(1, 2));
    l1.push_back(AA(1, 2));
    list<AA>::iterator it = l1.begin();
    while (it != l1.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
}

运行结果报错信息如下：

image-20230704160949768

我们可以通过重载流插入<<和流提取>>运算符解决问题，也可以通过下面的方式访问：

struct AA {
    int _a1;
    int _a2;
    AA(int a1 = 0, int a2 = 0)
        :_a1(a1)
        ,_a2(a2)
        {

        }
}; 
void test_list2()
{
    list<AA> l1;
    l1.push_back(AA(1, 2));
    l1.push_back(AA(1, 2));
    l1.push_back(AA(1, 2));
    list<AA>::iterator it = l1.begin();
    while (it != l1.end())
    {
        cout << (*it)._a1 << " " << (*it)._a2 << endl;
        ++it;
    }
    cout << endl;
}

但是这种方法有点麻烦，当我们有一个AA* ptr类型的指针时，我们通常使用->进行解引用：

AA* ptr = new AA(3,4);
cout << ptr->_a1 << " " << ptr->_a2 << endl;

所以迭代器也要去重载->，因为模拟的是指针的行为，所以也要支持使用->解引用。

在迭代器类中实现重载->：

//重载->，这里返回的相当于AA*
T* operator->()
{
    return &_node->_data;
}

然后测试代码就可以使用->：

void test_list2()
{
    list<AA> l1;
    l1.push_back(AA(1, 2));
    l1.push_back(AA(1, 2));
    l1.push_back(AA(1, 2));
    list<AA>::iterator it = l1.begin();
    while (it != l1.end())
    {
        //cout << it.operator->()->_a1  << it.operator->()->_a2 << endl;
        //可优化为下面这样：
        cout << it->_a1 << " " << it->_a2 << endl;
        ++it;
    }
    cout << endl;
}

image-20230704163309760

而当是const迭代器的时候返回值就是const T*，所以我们可以在迭代器类中再加一个模板参数Ptr用来表示->返回值：

//迭代器类
template<class T,class Ref,class Ptr>
struct __list_iterator {
    typedef list_node<T> node;
    typedef __list_iterator<T,Ref,Ptr> self;
    //重载->，这里返回的相当于AA*
    Ptr operator->()
    {
        return &_node->_data;
    }
}

在list类中通过模板参数控制返回值：

template<class T>
class list {
    //将节点类型重命名为node
    typedef list_node<T> node;
    public:
    //将迭代器类重命名为iterator
    typedef __list_iterator<T,T&,T*> iterator;
    typedef __list_iterator<T,const T&,const T*> const_iterator;
}

list类常用接口模拟实现

链表中只要实现了insert和erase，头插头删和尾插尾删都可以实现，所以我们先实现insert和erase函数。

insert函数

在pos位置之前插入一个新结点。

//在pos位置之前插入一个新结点
void insert(iterator pos,const T& val)
{
    node* cur = pos._node;
    node* prev = cur->_prev;
    node* new_node = new node(val);

    prev->_next = new_node;
    new_node->_prev = prev;
    new_node->_next = cur;
    cur->_prev = new_node;
}

list的迭代器不会失效，因为pos的指向不会改变，且它们的位置关系没有改变。

测试代码：迭代器pos的指向都是同一个位置。

void test_list1()
{
    list<int> l1;
    l1.push_back(1);
    list<int>::iterator it = l1.begin();
    while (it != l1.end())
    {
        cout << *it << " ";
        ++it;
    }
    //输出1
    cout << endl;
    list<int>::iterator pos = l1.begin();
    l1.insert(pos, 5);
    l1.insert(pos, 6);
    l1.insert(pos, 7);

    it = l1.begin();
    while (it != l1.end())
    {
        cout << *it << " ";
        ++it;
    }
    //输出5 6 7 1
    cout << endl;
}

有了插入之后头插和尾插就可以复用insert：

//尾插
void push_back(const T& x )
{
    //node* tail = _head->_prev;//这就是尾
    //node* new_node = new node(x);

    //tail->_next = new_node;
    //new_node->_prev = tail;
    //new_node->_next = _head;
    //_head->_prev = new_node;
    insert(end(), x);
}
//头插
void push_front(const T& x)
{
    insert(begin(), x);
}

erase函数

删除pos位置的结点。

void erase(iterator pos)
{
    //头结点不能被删除
    assert(pos != _head);
	//记录pos位置结点的前后结点
    node* prev = pos._node->_prev;
    node* next = pos._node->_next;

    //将pos结点移出list
    prev->_next = next;
    next->_prev = prev;
	
    //释放结点
    delete pos._node;
}

注意erase删除之后迭代器会失效。

迭代器失效是指迭代器所指向的节点失效，list中即节点被删除了，erase函数执行后，it所指向的节点被删除，因此it无效，在下一次使用it时，必须先给it赋值。

复用erase实现头删和尾删：

//尾删
void pop_back()
{
    erase(--end());
}
//头删
void pop_front()
{
    erase(begin());
}

注意引入模板参数之后类名已经不能做类型了，类名加模板参数才是类型。

**迭代器不需要关心模板参数是什么，直接使用就可以。vector的迭代器不一定是原生指针，有可能是被封装的。**我们可以通过typeid().name()函数查看类型。

image-20230704172721950

重载运算符可以由我们自己实现，关于迭代器失效问题具体问题具体对待。

list<int> l1;
//使用迭代器
list<int>::iterator it = l1.begin();
while (it != l1.end())
{
    cout << *it << " ";
    ++it;
}

//直接使用结点来定义
list_node<int>* pnode = l1._head->_next;

上面代码中分别使用迭代器和结点来直接定义，如果没有访问限定符的限制，那么上面两个一样吗？从物理空间上看一样，但是我们不能使用pnode遍历，因为++的结果不一样，*pnode是原生指针的解引用，pnode++只是加了一个指针，因为空间不连续并不一定能找到下一个结点。

既然erase之后迭代器失效，那么就要对erase进行修改，要有返回值：返回当前位置的下一个元素。

iterator erase(iterator pos)
{
    //头结点不能被删除
    assert(pos != _head);
	//记录pos位置结点的前后结点
    node* prev = pos._node->_prev;
    node* next = pos._node->_next;

    //将pos结点移出list
    prev->_next = next;
    next->_prev = prev;
	
    //释放结点
    delete pos._node;
    //返回下一个结点
    return iterator(next);
}

clear函数

清空list

void clear()
{
    iterator it = begin();
    while (it != end())
    {
        //it = erase(it);//erase会返回当前元素的下一个位置。
        erase(it++);
    }
}

我们也可以使用erase(it++)，因为后置++返回的是++之前的值，erase的不是it，是返回的it的拷贝。

迭代器中后置++：

//重载后置++
self operator++(int)
{
    self tmp(*this);
    _node = _node->_next;
    return tmp;
}

构造函数

默认构造函数

要push_back的前提要有哨兵位的头结点，所以要先建立一个头结点。我们可以学库里直接建立一个empty_init函数，用来建立头节点，用来初始化，构造函数调用就可以了。

void empty_init()
{
    _head = new node;
    _head->_next = _head;
    _head->_prev = _head;
}
list()
{
    empty_init();
}

有迭代器区间的构造函数

template<class Iterator>
list(Iterator first, Iterator last)
{
    empty_init();
    while (first != last)
    {
        push_back(*first);
        ++first;
    }
}

const对象可不可以调用构造函数？

可以，const对象定义的时候没有const属性，如：const int n = 2，否则const对象怎么初始化。

拷贝构造函数

注意也要给定头节点，先进行初始化，调用empty_init函数，再通过尾插将被拷贝list内容拷贝到新容器中。

传统写法：

void empty_init()
{
	_head = new node;
	_head->_next = _head;
	_head->_prev = _head;
}
 
list(const list<T>& lt)
{
	empty_init();
	for ( auto e : lt)
	{
		push_back(e);
	}
}

现代写法：

//先实现交换函数，交换两个链表的头节点
void swap(list<T>& tmp)
{
    std::swap(_head, tmp._head);
}

list(const list<int>& lt)
{
    empty_init();//初始化
    list<T> tmp(lt.begin(), lt.end());//使用迭代器区间构造
    swap(tmp);//调用swap函数交换头节点
}

赋值运算符重载

void swap(list<T>& tmp)
{
    std::swap(_head, tmp._head);
}
//l1 = l2

list<T>& operator=(list<T> lt)
{
    swap(lt);
    return *this;
}

通过传值传参调用拷贝构造函数构造出一个临时对象，然后通过交换头节点实现赋值。不能使用引用，使用引用就相当于将l3和l1的头节点交换，就改变了l3的值，相当于两者交换了并不能正确完成拷贝。

析构函数

~list()
{
    //先将list中数据清空
    clear();
    //再将头结点删除
    delete _head;
    //指向空
    _head = nullptr;
}

对比vector和list

vector与list都是STL中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不同，其主要不同如下：

vectorlist
底层结构动态顺序表，一段连续的空间带头结点的双向循环链表
随机访问支持随机访问，访问任意元素的效率O(1)不支持随机访问，访问某个元素的效率O(N)
插入和删除任意位置插入和删除效率低，需要移动元素，时间复杂度为O(N)，插入时可能需要增容（开辟新空间，拷贝元素，释放旧空间），导致效率更低任意位置插入和删除效率高，不需要移动元素，时间复杂度为O(1)
空间利用率底层为连续空间，不容易造成内存碎片，空间利用率高，缓存利用率高底层节点动态开辟，小节点容易造成内存碎片，空间利用率低， 缓存利用率低
迭代器原生态指针对原生态指针(节点指针)进行封装
迭代器失效在插入元素时，要给所有的迭代器重新赋值，因为插入 元素有可能会导致重新扩容，致使原来迭代器失效，删除时，当前迭代器需要重新赋值否则会失效插入元素不会导致迭代器失效， 删除元素时，只会导致当前迭代 器失效，其他迭代器不受影响
使用场景需要高效存储，支持随机访问，不关心插入删除效率大量插入和删除操作，不关心随机访问

list的反向迭代器

正向迭代器的++运算符重载是向后走，即向着_next指针走；而反向迭代器的++运算符重载是沿着_prev方向走，我们可以通过将list迭代器的代码改造一下：修改的地方主要就是将正向迭代器的重载++运算符中改成_prev，重载--运算符中改为_next。

list的反向迭代器代码如下：

//反向迭代器
template<class T, class Ref, class Ptr>
struct __list_reverse_iterator {
    typedef list_node<T> node;
    typedef __list_reverse_iterator<T, Ref, Ptr> self;
    node* _node;

    //构造一个迭代器,用结点的指针构造
    __list_reverse_iterator(node* n)
        :_node(n)
        {

        }
    Ref operator*()
    {
        return _node->_data;
    }
    Ptr operator->()
    {
        return &_node->_data;
    }
    self& operator++()
    {
        _node = _node->_prev;
        return *this;
    }
    //后置++
    self operator++(int)
    {
        self tmp(*this);
        _node = _node->_prev;
        return tmp;
    }

    self& operator--()
    {
        _node = _node->_next;
        return *this;
    }

    self operator--(int)
    {
        self tmp(*this);
        _node = _node->_next;
        return tmp;
    }
    //不相等比较的就是结点的指针
    bool operator!=(const self& s)
    {
        return _node != s._node;
    }
    bool operator==(const self& s)
    {
        return _node == s._node;
    }
};

然后在list类中将反向迭代器类重命名以及rbegin和rend函数：

template<class T>
class list {
    //将节点类型重命名为node
    typedef list_node<T> node;
public:
    void empty_init()
    {
        _head = new node;
        _head->_next = _head;
        _head->_prev = _head;
    }

    //将迭代器类重命名为iterator
    typedef __list_iterator<T,T&,T*> iterator;
    typedef __list_iterator<T,const T&,const T*> const_iterator;
    //将反向迭代器类重命名为 reverse_iterator
    typedef __list_reverse_iterator<T, T&, T*> reverse_iterator;
    typedef __list_reverse_iterator<T, const T&, const T*> const_reverse_iterator;
    list()
    {
        empty_init();
    }
    list(const list<T>& lt)
    {
        empty_init();
        for (auto e : lt)
        {
            push_back(e);
        }
    }
    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);
    }
    
    //反向迭代器对应函数
    reverse_iterator rbegin()
    {
        return reverse_iterator(_head->_prev);
    }
    reverse_iterator rend()
    {
        return reverse_iterator(_head);
    }
    const_reverse_iterator rbegin() const
    {
        return const_reverse_iterator(_head->_prev);
    }
    const_reverse_iterator rend() const
    {
        return const_reverse_iterator(_head); 
    }
private:
    node* _head;
};

测试：

void test_list()
{
    list<int> lt;
    lt.push_back(1);
    lt.push_back(2);
    lt.push_back(3);
    lt.push_back(4);
    lt.push_back(5);
    list<int>::iterator it = lt.begin();
    while (it != lt.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;

    //反向迭代器
    list<int>::reverse_iterator rit = lt.rbegin();
    while (rit != lt.rend())
    {
        cout << (*rit) << " ";
        ++rit;
    }
    cout << endl;
}

输出结果：

image-20230704211417861

上面begin和end、rbegin和rend的指向刚开始的位置如下：

image-20230704212756291

但是库中的反向迭代器是通过正向迭代器完成的， 库中这种方法使反向迭代器作为一种正向迭代器的适配器模式，可以生产出任何容器的反向迭代器，只要正向迭代器可以正常工作，那么反向迭代器就能够正常的工作。库中begin和end、rbegin和rend的指向刚开始的位置如下：

image-20230704230641835

如果是上面这样刚开始头结点的位置不能解引用即rbegin位置不能解引用，此时我们如果想要实现倒序遍历就要对*重新进行重载，在重载*函数内让其对上一个位置进行解引用。

重载解引用返回的时候，返回值是个问题，我们可以再定义两个模板参数解决。此时我们就不用再用上面那种反向迭代器实现，可以在新的头文件中定义：

#pragma once
namespace Niu {
	template<class Iterator, class Ref, class Ptr>
    struct ReverseIterator {
        typedef ReverseIterator<Iterator, Ref, Ptr> Self;
        Iterator _cur;

        //我去用正向迭代器去构造一个方向迭代器
        ReverseIterator(Iterator it)
            :_cur(it)
            {

            }
        //重载*
        Ref operator*()
        {
            Iterator tmp = _cur;//拷贝构造
            --tmp;
            return *tmp;//返回上一个结点
        }
        Self& operator++()
        {
            --_cur;
            return *this;
        }
        Self& operator--()
        {
            ++_cur;
            return *this;
        }
        bool operator!=(const Self& s)
        {
            //反向迭代器和正向迭代器都是指针可以直接判断
            return  _cur != s._cur;
        }
    };
}

在类list中定义：

typedef ReverseIterator<iterator, T&,  T*> reverse_iterator;
typedef ReverseIterator<iterator, const T&, const T*> const_reverse_iterator;

此时list类中的rbegin和rend函数也要修改：

reverse_iterator rbegin()
{
    return reverse_iterator(end());
}
reverse_iterator rend()
{
    return reverse_iterator(begin());
}

此时再测试：

void test_list()
{
    list<int> lt;
    lt.push_back(1);
    lt.push_back(2);
    lt.push_back(3);
    lt.push_back(4);
    lt.push_back(5);
    list<int>::iterator it = lt.begin();
    while (it != lt.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;

    //反向迭代器
    list<int>::reverse_iterator rit = lt.rbegin();
    while (rit != lt.rend())
    {
        cout << (*rit) << " ";
        ++rit;
    }
    cout << endl;
}

测试结果：

image-20230704234036262

我们使用模板，只要实现了一个迭代器，所有的迭代器都出来了，但是要求必须是双向迭代器，支持--才能使用，如list和vector。

list可以拷贝一份正向迭代器改造成反向迭代器，但是vector不能解决，因为vector本身就是内置类型。此时我们通过模板给vector的正向迭代器可以得到vector的反向迭代器：

namespace Niu {
	template<class T>
	class vector {
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
		typedef ReverseIterator<iterator, const T&, const T*> const_reverse_iterator;
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}
		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}
        ……
    };
}

测试：

void test_vector2()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);
    //正向遍历
    vector<int>::iterator it = v.begin();
    while (it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;

    //反向迭代器
    vector<int>::reverse_iterator rit = v.rbegin();
    while (rit != v.rend())
    {
        cout << (*rit) << " ";
        ++rit;
    }
    cout << endl;
}

测试结果：

image-20230704233816526

不 良
关注
  • 17
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
list模拟实现
qq_68006585的博客
03-07 480
list模拟实现
【C++】list的模拟实现
qq_62939852的博客
03-11 1283
C++中，Listnode作为类名，而next和prev都是类指针，指针引用成员时使用->，而对象引用成员时使用 .若在数组上有一个int类型的指针，解引用是int类型的数据，再++可以加载下一个位置，因为物理空间是连续的。erase函数执行后，it所指向的节点被删除，因此it无效，在下一次使用it时，必须先给it赋值。同样若在链表上，解引用类型为 node，再++不能到下一个节点，因为物理空间不连续。++pnode，找到下一个节点的地址，但是下一个节点不一定是要的节点。
list的模拟实现
m0_68641696的博客
06-10 2224
list是vector中重要的容器，了解它的原理对于我们掌握它是有很多的帮助的，一般list和vector都是一起来使用的，因为它们的优缺点不同，刚好可以互补。list的优点是任意位置的插入和删除都很快，它的缺点是不支持随机访问，而vector的优点是支持随机访问，进而就可以很好的支持排序算法，二分查找，堆算法等，它的缺点是扩容要付出一定的代价，而且除了尾上的插入和删除外其他位置的插入和删除都不快（因为要挪动数据）。下面让我们一起来实现一下list吧。
【C++】list的模拟实现【完整理解版】
最新发布
m0_74044018的博客
09-10 1036
list的模拟实现，主讲你不理解的地方，每个地方都会详细解释，重在理解
模拟实现list超详解（C++）
m0_67430750的博客
04-25 3107
简易版list模拟实现超详解
C++模拟实现list
03-11
C++模拟实现list
C++ 模拟实现list(迭代器)实现代码
01-01
C++ 模拟实现list(迭代器) 实现代码： #pragma once; #include #include #include using namespace std; template struct __ListNode { T _data; __ListNode* _next; __ListNode* _prev; __ListNode(const T&...
c模拟c++ stl list
06-18
实现c++ list部分功能，内存自管理 函数的使用和c++ stl list类似，并不完全相同 简单测试过，并不保证完全无错，仅供参考
List各个接口模拟实现
08-27
List各个接口模拟实现
【C++】list类模拟实现
qq_66314292的博客
11-09 1860
list类的模拟实现
list简单模拟实现
L_listen的博客
10-28 303
#define _CRT_SECURE_NO_WARNINGS #pragma once #include <assert.h> #include <iostream> using namespace std; template<class T> struct ListNode { ListNode(const T& data = T()) :_pPre(0) , _pNex
STL之list的模拟实现
Code_beeps的博客
06-11 287
实现的功能：迭代器、反向迭代器、以及list的各种接口 list.h namespace myList { ////List的结点类 template<class T> class ListNode { public: ListNode(const T& val = T()) :_data(val) , _next(nullptr) , _pre...
[STL]list模拟实现
Protein_zmm的博客
07-24 299
stl中list的模拟实现
【list的模拟实现】
Willing_hope的博客
08-10 158
1、list的迭代器底层实现 用一个类型去封装结点的指针，构成一个自定义类型，然后重载*和++等运算符,使其可以像指针一样进行使用。 2、模拟实现list 刚开始实现的初步工作就是实现一个双向循环链表，并且指向自己。 ...
【STL详解】list的模拟实现
Holden_Caulfield的博客
03-29 1060
目录 list的模拟实现总览： 1.节点类的模拟实现 构造函数 2.迭代器类的模拟实现 迭代器类的模板参数说明 构造函数 ++运算符的重载 --运算符的重载 ==运算符的重载 !=运算符的重载 *运算符的重载 ->运算符的重载 list的模拟实现 默认成员函数 构造函数 拷贝构造函数（迭代器版本） 拷贝构造函数(现代写法) 赋值运算符重载函数（现代写法） 其他构造函数 析构函数 迭代器相关函数 访问容器相关函数 插入、删除函数 insert（...
c++模拟实现vector
09-01
- *1* *2* *3* [C++——vector模拟实现](https://blog.csdn.net/weixin_49449676/article/details/126813526)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不 良

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值