c++stl 之list的底层理解及其模拟实现

最新推荐文章于 2024-12-02 20:11:38 发布
原创 最新推荐文章于 2024-12-02 20:11:38 发布 · 535 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #list #数据结构

本文详细探讨了C++ STL中的list容器，包括list的构造、迭代器使用、容量、元素访问、修改操作及迭代器失效情况。重点介绍了list作为双向循环链表的特性，指出在list中插入元素不会使迭代器失效，而删除会导致指向被删除节点的迭代器失效。此外，还探讨了list的模拟实现和反向迭代器的实现，并与vector进行了对比。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

一、 list的使用

1.1 list的构造

构造函数（ (constructor)）接口说明
list (size_type n, const value_type& val = value_type())构造的list中包含n个值为val的元素
list()构造空的list
list (const list& x)拷贝构造函数
list (InputIterator first, InputIterator last)用[first, last)区间中的元素构造list

1.2 list iterator的使用

此处，大家可暂时将迭代器理解成一个指针，该指针指向list中的某个节点。
在这里插入图片描述
【注意】

  1. begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动
  2. rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动

1.3 list capacity

在这里插入图片描述

1.4 list element access

在这里插入图片描述

1.5 list modifiers

函数声明接口说明
push_front在list首元素前插入值为val的元素
pop_front删除list中第一个元素
push_back在list尾部插入值为val的元素
pop_back删除list中最后一个元素
insert在list position 位置中插入值为val的元素
erase删除list position位置的元素
swap交换两个list中的元素
clear清空list中的有效元素

1.6 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的模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<iostream>
#include<assert.h>
#include "reverse_iterator.h"
using namespace std;
namespace sk
{
	//构造链表
	template <class T>
	struct ListNode
	{
		ListNode(const T& val = T())
			:_prev(nullptr)
			,_next(nullptr)
			,_val(val)
		{}

		ListNode<T>* _prev;
		ListNode<T>* _next;
		T _val;
	};
	//list迭代器封装
	template <class T, class Ref, class Ptr>
	class __list_iterator
	{
		typedef ListNode<T> Node;
		typedef __list_iterator<T, Ref, Ptr> Self;
		
	public:
		Node* _node;

		__list_iterator(Node* x)
			:_node(x)
		{}
		Ref operator*()
		{
			return _node->_val;
		}
		Ptr operator->()
		{
			return &(_node->_val);
		}
		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& it)const
		{
			return _node != it._node;
		}
		bool operator==(const Self& it)const
		{
			return _node != it._node;
		}
	};
	//list功能实现
	template <class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		typedef __list_iterator<T, T&, T*> iterator;
		typedef __list_iterator<T, const T&, const T*> const_iterator;

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


		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());
		}

		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);
		}

		list()
			:_head(nullptr)
		{
			empty_initiablize();
		}


        //深拷贝
		list(int n, const T& val = T())
		{
			empty_initiablize();

			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		template <class Inputiterator>
		list(Inputiterator first, Inputiterator last)
		{
			empty_initiablize();

			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}
		
		list(const list<T>& l)
		{
			empty_initiablize();

			list<T> tmp(l.begin(), l.end());
			swap(_head, tmp._head);
		}
		iterator& operator=(list<T> l)
		{
			swap(_head, l._head);
			return *this;
		}
		//析构
		~list() 
		{
			clear();
			delete _head;
			_head = nullptr;
		}
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
		void empty_initiablize()
		{
			_head = new Node(T());
			_head->_next = _head;
			_head->_prev = _head;

			_size
		}
		size_t size()const
		{
			size_t count = 0;
			const_iterator it = begin();
			while (it != end())
			{
				count++;
				it++;
			}
			return count;
		}
		bool empty()const
		{
			return _head->_next == _head;
		}
		T& front()
		{
			return _head->_next->_val;
		}
		const T& front()const
		{
			return _head->_next->_val;
		}
		T& back()
		{
			return _head->_prev->_val;
		}
		const T& back()const
		{
			return _head->_prev->_val;
		}
		void push_front(const T& val)
		{
			insert(begin(), val);
		}
		void push_back(const T& val)
		{
			//Node* newnode = new Node(val);
			//Node* tail = _head->_prev;
			//newnode->_prev = tail;
			//newnode->_next = tail->_next;
			//tail->_next->_prev = newnode;
			//tail->_next = newnode;
			insert(end(), val);
		}
		void pop_front()
		{
			erase(begin());
		}
		void pop_back()
		{
			erase(--end());
		}
		//寻找
		iterator find(const T& val)
		{
			iterator it = begin();
			while(it != end())
			{
				if (*it == val)
				{
					return it;
				}
				++it;
			}
			return nullptr;
		}
		//指定位置插入
		iterator insert(iterator pos, const T& val)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* newnode = new Node(val);
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			prev->_next = newnode;
			return iterator(newnode);
		}
		//指定位置删除
		iterator erase(iterator pos)
		{
			assert(pos!= end());
			Node* cur = pos._node;
			Node* next = cur->_next;
			next->_prev = cur->_prev;
			cur->_prev->_next = next;
			delete cur;
			pos._node = next;
			return iterator(next);
		}
	private:
		Node* _head;
	};
	class Date
	{
	public:
		Date(size_t year = 1, size_t month = 1, size_t day = 1)
			:_year(year)
			,_month(month)
			,_day(day)
		{}
	//private:
		size_t _year;
		size_t _month;
		size_t _day;
	};
	void print_list(const list<int>& l)
	{
		list<int>::const_iterator it = l.begin();
		while (it != l.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}
	void test_list1()
	{
		list<int> l;
		l.push_back(1);
		l.push_back(2);
		l.push_back(3);
		l.push_back(4);
		print_list(l);
	}
	void test_list2()
	{
		list<Date> l;
		l.push_back(Date(2012, 2, 3));
		l.push_back(Date(2012, 2, 4));
		l.push_back(Date(2012, 2, 5));
		l.push_back(Date(2012, 2, 6));
		list<Date>::iterator it = l.begin();
		while (it != l.end())
		{
			cout << it->_year << "-" << it->_month << "-" << it->_day << endl;
			it++;
		}
	}
	void test_list3()
	{
		list<int> l;
		l.push_back(1);
		l.push_back(2);
		l.push_back(3);
		l.push_back(4);
		list<int>::iterator pos = l.find(3);
		print_list(l);
		l.push_front(10);
		pos = l.begin();
		l.insert(l.end(), 9);
		print_list(l);
	}
	void test_list4()
	{
		list<int> l;
		l.push_back(1);
		l.push_back(2);
		l.push_back(3);
		l.push_back(4);
		print_list(l);
		l.pop_front();
		print_list(l);
		l.pop_back();
		print_list(l);
	}
	void test_list5()
	{
		list<int> l1;
		l1.push_back(1);
		l1.push_back(2);
		l1.push_back(3);
		l1.push_back(4);
		list<int> l2(l1);
		print_list(l2);
		list<int> l3 = l2;
		print_list(l3);

		list<Date> l4(5, Date(2011,1,1));
		list<Date>::iterator it = l4.begin();
		for (auto &d : l4)
		{
			cout << d._year << "-" << d._month << "-" << d._day << endl;
		}

		list<int> l5(5, 1);
		print_list(l5);
	}
	void test_list6()
	{
		list<int> l1;
		l1.push_back(1);
		l1.push_back(2);
		l1.push_back(3);
		l1.push_back(4);
		cout << l1.size() << endl;
		cout << l1.empty() << endl;
		cout << l1.front() << endl;
		cout << l1.back() << endl;
	}
	void test_list7()
	{
		list<int> l1;
		l1.push_back(1);
		l1.push_back(2);
		l1.push_back(3);
		l1.push_back(4);
		list<Date> l4;
		l4.push_back(Date(2012, 1, 1));
		l4.push_back(Date(2012, 2, 2));
		l4.push_back(Date(2012, 3, 3));
		l4.push_back(Date(2012, 4, 4));
		list<Date>::reverse_iterator rit = l4.rbegin();
		while(rit != l4.rend())
		{
			cout << rit->_year << "-" << rit->_month << "-" << rit->_day << endl;
			rit++;
		}
	}
}

三、反向迭代器的实现

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once

namespace sk
{
	template <class iterator, class Ref, class Ptr>
	class reverse_iterator
	{
		typedef reverse_iterator<iterator, Ref, Ptr> Self;
	public:
		reverse_iterator(iterator x)
			:_it(x)
		{}
		Ref operator*()
		{
			iterator prev = _it;
			return *(--prev);
		}
		Ptr operator->()
		{
			return &(operator*());
		}
		Self& operator++()
		{
			--_it;
			return *this;
		}
		Self& operator++(int)
		{
			_it--;
			return *this;
		}
		Self& operator--()
		{
			++_it;
			return *this;
		}
		Self& operator--(int)
		{
			_it++;
			return *this;
		}
		bool operator!=(const Self& rit)const
		{
			return rit._it != _it;
		}
	private:
		iterator _it;
	};
}

四、list与vector的对比

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

vectorlist
底 层 结 构动态顺序表，一段连续空间带头结点的双向循环链表
随 机 访 问支持随机访问，访问某个元素效率O(1)不支持随机访问，访问某个元素效率O(N)
插 入 和 删 除任意位置插入和删除效率低，需要搬移元素，时间复杂度为O(N)，插入时有可能需要增容，增容：开辟新空间，拷贝元素，释放旧空间，导致效率更低任意位置插入和删除效率高，不需要搬移元素，时间复杂度为O(1)
空 间 利 用 率底层为连续空间，不容易造成内存碎片，空间利用率高，缓存利用率高底层节点动态开辟，小节点容易造成内存碎片，空间利用率低，缓存利用率低
迭 代 器原生态指针对原生态指针(节点指针)进行封装
迭 代 器 失 效在插入元素时，要给所有的迭代器重新赋值，因为插入元素有可能会导致重新扩容，致使原来迭代器失效，删除时，当前迭代器需要重新赋值否则会失效插入元素不会导致迭代器失效，删除元素时，只会导致当前迭代器失效，其他迭代器不受影响
使 用 场 景需要高效存储，支持随机访问，不关心插入删除效率大量插入和删除操作，不关心随机访问
C++ List容器的底层实现
TABE_的博客
04-11 1960
这里写目录标题list 容器节点结构list容器迭代器的底层实现list容器的底层实现 list 容器节点结构 通过查看 list 容器的源码实现，其对节点的定义如下： template<typename T,...> struct __List_node{ //... __list_node<T>* prev; __list_node<T>* next; T myval; //... } 可以看到，list 容器定义的每个节点
【C++ 初阶】List底层框架模拟实现
HenryBlog
11-21 1234
目录一、List框架搭建1. List简介2. List使用案例1. List简介1. List简介1. List简介1. List简介1. List简介1. List简介1. List简介二、完整代码 一、List框架搭建 1. List简介 list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。 list的底层是带头双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。 与其他的序列式容器相比(array，ve
C++list简单底层实现代码
weixin_58666778的博客
04-10 1228
#pragma once #include"reverse_iterator.h" namespace zh { //list单个节点的类 template<class T> struct ListNode { ListNode<T>* _next; ListNode<T>* _prev; T _data; ListNode(const T& x = T()) :_data(x) , _next(nullptr) , _
C++ list容器的底层实现
weixin_70485831的博客
07-09 1112
链表中的数据和前后指针的类型都是模板生成的，可以适配内置类型和自定义类型。这里用struct来定义类的原因是struct默认的成员变量类型都是public，其他函数可以很方便的进行调用。在这里还有一个list_node的构造函数 T()是一个匿名变量，其作用不止是用于存放数据，此外如果调用list_node构造函数时没有写参数的话，这里也会有一个默认的值。在list中，有两个成员变量的存在一个是节点类型的指针_node 和计算节点数量的_size。
C++基础:list的底层实现
最新发布
2302_82004664的博客
12-02 1439
但是这里会有些问题,在函数外面写的范围for支持,而函数内的范围for不支持了。这样我们只需要在调用的时候将要返回的参数写下来就能返回我们想要的迭代器。但是这样实现代码就显得重复度很高了,能不能直降返回的那部分替换掉呢?当然为了放在删除后迭代器失效,我们可以再删除后返回下一个节点的位置。当尾插写完后我们的其他插入方式就可以直接进行调用了。写完后我们就可以来完成begin和end的返回了。再将最后一个尾节点和头相连,成为新的尾节点。这里我们呢直接用新写法进行交换就行。将将节点的链接方式改变一下就行了。
C++ STL之list的使用及模拟实现
czh1592272237的博客
01-23 2169
本篇文章详细讲解了STL中list的使用及模拟实现，以及反向迭代器类模板的实现。
C++ stl容器list的底层模拟实现
2301_79698419的博客
04-17 1990
list的底层模拟实现
C++标准模板库STL——list的使用及其模拟实现
希望自己从编程小白变成大佬
09-25 1309
list的文档介绍1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
C++ STL专题 list的底层实现
Mike的博客
08-07 1649
void empty_init()函数在list类中有着重要作用，其作用为初始化链表为空状态的作用，这个函数的主要目的是创建一个哑节点(哨兵节点)，并设置链表的初始状态，使链表在逻辑上是空的。这个函数接受一个类型为constT&的参数x，即要插入的新元素的一个常量引用。(1).++后置中，由于是先赋值再自加，所以要先把改变之前的值保持在tmp中，再对_node作改变，最后返回的是tmp。(2).--后置中，由于是先赋值再自减，所以要先把改变之前的值保持在tmp中，再对_node作改变，最后返回的是tmp。
【C++】-- STL之list模拟实现
局部变量和全局变量
06-09 1906
list链表的模拟实现，与前面的string和vector相比，略复杂一点： （1）由于链表节点本身就是一个结构体，包含数据域、指针域。 将节点的相关操作放入节点类进行处理，逻辑更清晰 （2）string和vector的元素在空间上是连续分布的，迭代器++就能指向下一个元素，但list的迭代器不行，它的每个元素在空间上都不连续，要访问下一个节点必须找到当前节点的next，因此list的迭代器必须重写............
c++list类实现
11-23
1）代码注释很详细的，非常适合学习STL的。 2）数据结构里面两种非常重要的存储结构，线性结构中的连续存储结构（代表vector数组）和非连续存储结构（代表list链表），他们两者被广泛的应用在各个领域，是最基本最基础的两种存储结构； 3）之前的友元类只是停留在理论层面，真正实现还是头一次；友元类非常像java中的内部类
C++ STL::list常用操作及底层实现（中1）——实现list常用操作之插入(insert、push_front、push_back、splice)
weixin_43744293的博客
06-07 2998
STL::list插入介绍及自实现插入功能1插入数据之insert()：1.1 `iterator insert(iterator position,const value_type & val);`1.2. ` iterator insert(iterator position,size_type n,const value_type & val);`1.3. `template iterator insert(iterator position, InputIterator fi
C语言建立链表并实现增删查改
GershonHold的博客
07-26 480
#include <stdio.h> #include <stdlib.h> #define ADDNUM 9 #define ADDPOS 3 #define DELPOS 3 #define SEARCHNUM 4 #define MODIFYNUM 27 typedef struct { int *head; int length; int ...
C++ List底层实现
lim6ere的博客
03-20 1232
我们都清楚c++中的容器list，本质上就是一个带头双向循环链表，接下来我们实现一下list的底层，帮助我们更深层次的了解list的结构和使用//我们要注意end是哪个位置以上就是今天要讲的内容，本文仅仅详细介绍了C++list的模拟实现，希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
【C++】list的使用及底层实现原理
weixin_67596609的博客
07-17 2763
本篇文章对list的使用进行了举例讲解。同时也对底层实现进行了讲解。底层的实现关键在于迭代器的实现。希望本篇文章会对你有所帮助。list底层实现关键是迭代器的实现。我们要清楚的是，list的迭代器底层就是一个对节点进行封装的类。初学可能会感觉有点难以理解。但是，应多看几遍理解整体结构就很容易清楚了。
list的讲解及模拟实现(c++)
weixin_49312527的博客
05-08 2575
与介绍vector时相同为了方便大家理解, 我们采用便模拟实现便讲解使用方式的方式, 展开对list容器的讲解. 一.list的介绍 使用时注意包含头文件: #include<list> list相关特性介绍: 1.list的底层是一个带头结点的双向循环链表. 2.list是可以在常数范围内在任意位置进行插入和删除的序列式容器, 并且该容器可以前后双向迭代. 3.list的底层是双向链表结构, 双向链表中每个元素存储在互不相关的独立节点中, 在节点中通过指针指向其前一个元素..
C++ list底层实现原理
qq_40135848的博客
07-29 1199
C++ list底层实现原理
C++ STL list容器底层实现（详解版）
白小飞
12-11 2780
前面在讲 STL list 容器时提到，该容器的底层是用双向链表实现的，甚至一些 STL 版本中（比如 SGI STL），list 容器的底层实现使用的是双向循环链表。 图 1 双向链表（ a) ）和双向循环链表（ b) ） 图 1 中，node 表示链表的头指针。 如图 1 所示，使用链表存储数据，并不会将它们存储到一整块连续的内存空间中。恰恰相反，各元素占用的存储空间（又称为节点）是独立的、分散的，它们之间的线性关系通过指针（图 1 以箭头表示）来维持。 list 容器节点结构 通过图 1 可以看到，
【C++_STL】list用法&底层实现
菜菜成长为后端开发大佬
07-23 1011
1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3. list与非常相似：最主要的不同在于是单链表，只能朝前迭代，已让其更简单高效。4.与其他的序列式容器相比(arrayvectordeque)list通常在任意位置进行插入、移除元素的执行效率更好。5.与其他序列式容器相比，list和。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值