C++ List 容器：实现原理深度解析

wangchen_02025-01-21 22:08

1.基本结构

1.1list底层

list底层是一个双向链表 ，每个节点包含三个主要部分：存储的数据 ，指向前一个节点 和后一个节点的指针。我们首先定义一个 list_node 结构体来描述链表节点。

cpp 复制代码 
template <class T>
struct list_node {
    T _data;
    list_node<T>* _next;
    list_node<T>* _prev;

    list_node(const T& x = T()) 
        : _data(x), _next(nullptr), _prev(nullptr) 
    {}
};

使用类模板定义以便处理不同类型的数据，同时写一个构造函数，将要插入list容器中的数据构造为一个双向指针。

例如我们要往list中插入一个值为value的数据，我们需要动态申请一个节点，而上面的构造函数就会将val构造为一个值为value的双向指针。

cpp 复制代码 
typedef list_node<T> Node;
Node* newnode = new Node(val);

1.2 实现迭代器

迭代器是容器的重要组成部分，它允许我们像使用指针一样遍历链表。因为list容器的底层是链表，所以迭代器有些特殊，与vector、list不同，需要特殊实现。

我们定义 list_iterator，用于遍历 list_node。

cpp 复制代码 
template <class T, class Ref, class Ptr>
struct list_iterator
{
	typedef list_node<T> Node;
	typedef list_iterator<T, Ref, Ptr> iterator;
	Node* _node;

	list_iterator(Node* node)
		:_node(node)
	{}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &_node->_data;
	}

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

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

	//前置
	iterator& operator++()
	{
		_node = _node->_next;
		return *this;
	}

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

	bool operator!=(const iterator& s)
	{
		return _node != s._node;
	}

	bool operator==(const iterator& s)
	{
		return _node == s._node;
	}

};

1.3 实现 list 容器

list 容器的核心实现依赖于双向链表。我们使用 list_node 和 list_iterator 构建 list 的功能。

cpp 复制代码 
template <class T>
class list
{
	typedef list_node<T> Node;
public:
	typedef list_iterator<T, T&, T*> iterator;
	typedef list_iterator<T, const T&, const T*> const_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);
	}

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

	list(){
		empty_init();
	}
	list(const list<T>& lt){
		empty_init();

		for (auto& e : lt)
		{
			push_back(e);
		}
	}

	list<T>& operator=(list<T> lt){
		swap(lt);
		return *this;
	}
	void swap(list<T>& tmp){
		std::swap(_head, tmp._head);
	}

	list(size_t n, const T& val = T()){
		empty_init();
		for (size_t i = 0; i < n; i++)
		{
			push_back(val);
		}
	}
	~list(){
		clear();

		delete _head;
		_head = nullptr;
	}
	void clear(){
		auto it = begin();
		while (it != end())
		{
			it = erase(it);
		}
	}

	iterator insert(iterator pos, const T& val){
		Node* cur = pos._node;
		Node* newnode = new Node(val);
		Node* prev = cur->_prev;

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

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

		return iterator(newnode);
	}

	void push_back(const T& x){
		insert(end(), x);
	}

	void push_front(const T& x){
		insert(begin(), x);
	}
	void pop_front()
	{
		erase(begin());
	}
	void pop_back()
	{
		erase(--end());
	}

	iterator erase(iterator pos)
	{
		assert(pos != end());

		Node* del = pos._node;
		Node* prev = del->_prev;
		Node* next = del->_next;

		prev->_next = next;
		next->_prev = prev;
		delete del;
		return iterator(next);
	}

private:
	Node* _head;
};

2. 迭代器剖析

2.1剖析 iterator

cpp 复制代码 
template<class T>
struct list_iterator
{
	typedef list_node<T> Node;
	typedef list_iterator<T> Self;
	Node* _node;

	list_iterator(Node* node)
		:_node(node)
	{}

	T& operator*()
	{
		return _node->_data;
	}

	T* operator->()
	{
		return &_node->_data;
	}

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

	Self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}

	Self operator++(int)
	{
		Self tmp(*this);
		_node = _node->_next;
		return tmp;
	}

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

	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}
};

在上面这段代码中：

cpp 复制代码 
typedef list_node<T> Node;
typedef list_iterator<T> Self;
Node* _node;

list_iterator(Node* node)
	:_node(node)
{}

（1）定义了一个**_node指针** ，指向当前迭代器所在的链表节点 ；接着是一个构造函数，用于初始化迭代器，使其指向当前节点。

例如，调用迭代器的begin（）方法，iterator就会调用lst_iterator结构体的构造函数 ，将_node初始化为_head->next所指向的节点。

cpp 复制代码 
typedef list_iterator<T> iterator;		
iterator begin(){
	return iterator(_head->_next);
}

（2）迭代器中的"* "解引用操作用来访问当前迭代器所指向的对象 ，所以我们直接返回该节点的数据 来达到预期的效果，并且返回的是一个数据类型T的一个引用 ，表示我们可以通过*操作符修改数据。

"-> "成员访问操作符，在迭代器中我们通常用它来指向节点的数据 ，即_node->data，因此我们直接返回该节点数据的地址 就可以达到期望效果，返回值是一个T类型的指针。这样我们通过->操作符就得到了指向所期望的节点的数据的指针。（指针 就是 地址）

cpp 复制代码 
T& operator*(){
	return _node->_data;
}

T* operator->(){
	return &_node->_data;
}

（3） 前置++和前置--首先是将当前指针指向下一个节点 ，这里调用了 上面我们实现的**->操作符** ，即_node得到了下一个节点的地址，也就是指向了下一个节点。

后置++和后置--先将当前节点保存下来，再修改_node指向，返回临时保存下来的指针。

cpp 复制代码 
//前置	
Self& operator++(){
		_node = _node->_next;
		return *this;
	}

	Self& operator--(){
		_node = _node->_prev;
		return *this;
	}
//后置
	Self operator++(int){
		Self tmp(*this);
		_node = _node->_next;
		return tmp;
	}

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

2.2 iterator与const_iterator的一体实现

上面所实现的代码是可修改的 iterator ，如果要实现const_iterato r，我们是否还要再写一个结构体呢？虽然可以再写一个结构体来实现const_iterator，但是使用两个结构体来是想这两种迭代器是不是有些太冗余了？我们是否可以通过一个结构体来实现这两种迭代器 呢？答案是可以，我们通过设置多个类模板参数就可以达到我们想要的效果。

对类模版不熟悉的小伙伴可以先去下面这篇有关模版的博客中学习

C++泛型编程：模版-CSDN博客

这里提一嘴：如果我们要实现方法都是公有的，通常用struct，如果有私有的则用class

一个结构体实现两种迭代器代码如下：

cpp 复制代码 
template <class T, class Ref, class Ptr>
struct list_iterator
{
	typedef list_node<T> Node;
	typedef list_iterator<T, Ref, Ptr> iterator;
	Node* _node;

	list_iterator(Node* node)
		:_node(node)
	{}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &_node->_data;
	}

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

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

	//前置
	iterator& operator++()
	{
		_node = _node->_next;
		return *this;
	}

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

	bool operator!=(const iterator& s)
	{
		return _node != s._node;
	}

	bool operator==(const iterator& s)
	{
		return _node == s._node;
	}

};

这段代码与iterator的不同之处仅在于模版参数，因为iterator和const_iterator最大的区别就是前者可以修改容器中的元素，而后者不能修改容器中的元素。它们的解引用操作和成员访问操作不同，而++、--等操作相同。因此只需要改变*、->两种操作。

使用iterator则传参数"T, T&, T*"，这种情况下与上面只能实现iterator的代码相同。

使用const_iterator则传参"T, const T&, const T*"，使得解引用操作和成员访问操作被const限制从而不能被修改。

cpp 复制代码 
template <class T, class Ref, class Ptr>
struct list_iterator
{
	typedef list_node<T> Node;
	typedef list_iterator<T, Ref, Ptr> iterator;

3.list容器剖析

cpp 复制代码 
template <class T>
class list
{
	typedef list_node<T> Node;
public:
	typedef list_iterator<T, T&, T*> iterator;
	typedef list_iterator<T, const T&, const T*> const_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);
	}

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

	list(){
		empty_init();
	}
	list(const list<T>& lt){
		empty_init();

		for (auto& e : lt)
		{
			push_back(e);
		}
	}

	list<T>& operator=(list<T> lt){
		swap(lt);
		return *this;
	}
	void swap(list<T>& tmp){
		std::swap(_head, tmp._head);
	}

	list(size_t n, const T& val = T()){
		empty_init();
		for (size_t i = 0; i < n; i++)
		{
			push_back(val);
		}
	}
	~list(){
		clear();

		delete _head;
		_head = nullptr;
	}
	void clear(){
		auto it = begin();
		while (it != end())
		{
			it = erase(it);
		}
	}

	iterator insert(iterator pos, const T& val){
		Node* cur = pos._node;
		Node* newnode = new Node(val);
		Node* prev = cur->_prev;

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

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

		return iterator(newnode);
	}

	void push_back(const T& x){
		insert(end(), x);
	}

	void push_front(const T& x){
		insert(begin(), x);
	}
	void pop_front()
	{
		erase(begin());
	}
	void pop_back()
	{
		erase(--end());
	}

	iterator erase(iterator pos)
	{
		assert(pos != end());

		Node* del = pos._node;
		Node* prev = del->_prev;
		Node* next = del->_next;

		prev->_next = next;
		next->_prev = prev;
		delete del;
		return iterator(next);
	}

private:
	Node* _head;
};

3.1 迭代器首尾的实现

cpp 复制代码 
typedef list_node<T> Node;
public:
	typedef list_iterator<T, T&, T*> iterator;
	typedef list_iterator<T, const T&, const T*> const_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);
	}

在构造实例时，会将_head初始化，当执行插入删除操作时，_head类似于一个哨兵头节点。end（）在链表最后一个元素后面一个位置，也就是_head，_head的下一个节点是第一个元素。

iterator begin()调用可修改迭代器，list_iterator的构造函数将_head->next初始化为一个指针节点。

const_iterator begin()调用const迭代器， list_iterator的构造函数将_head->next初始化为一个指针节点。同时该指针节点的解引用和成员访问受const保护。

3.2 构造和析构

cpp 复制代码 
void empty_init(){
		_head = new Node();
		_head->_next = _head;
		_head->_prev = _head;
	}

	list(){
		empty_init();
	}
	list(const list<T>& lt){
		empty_init();

		for (auto& e : lt)
		{
			push_back(e);
		}
	}

	list<T>& operator=(list<T> lt){
		swap(lt);
		return *this;
	}
	void swap(list<T>& tmp){
		std::swap(_head, tmp._head);
	}

	list(size_t n, const T& val = T()){
		empty_init();
		for (size_t i = 0; i < n; i++)
		{
			push_back(val);
		}
	}
	~list(){
		clear();

		delete _head;
		_head = nullptr;
	}

（1）默认构造调用空初始化，动态分配一个节点空间 ，前后指针都指向自己。例如：

cpp 复制代码 
henu::list<int> lt1;

（2）拷贝构造，先空初始化申请空间，再将要拷贝的内容一个一个的push_back到申请的空间中

cpp 复制代码 
list(const list<T>& lt){
	empty_init();
    for (auto& e : lt){
		push_back(e);
	}
}
list(size_t n, const T& val = T()){
	empty_init();
	for (size_t i = 0; i < n; i++)
	{
		push_back(val);
	}
}

（3）这是一种构造的特殊实现方式，将要拷贝的内容 直接与目标变量交换 ，而由于没有传地址也没有引用传参 ，所以在此函数作用域中所进行的修改不会对原变量产生任何影响。

cpp 复制代码 
list<T>& operator=(list<T> lt){
		swap(lt);
		return *this;
	}
	void swap(list<T>& tmp){
		std::swap(_head, tmp._head);
	}

（4） 析构，使用clear删除每一个节点，最后删除头结点，将其置为空

cpp 复制代码 
~list(){
	clear();

	delete _head;
	_head = nullptr;
}
void clear(){
	auto it = begin();
	while (it != end())
	{
		it = erase(it);
	}
}

3.3 插入删除

（1）插入操作首先定义一个临时节点cur指向要插入的位置pos ，再定义一个节点指向cur的前一个位置 ，随后给新节点申请空间并初始化 ，然后就是新插入节点与两边节点 前后指针的重新指向。

cpp 复制代码 
iterator insert(iterator pos, const T& val){
		Node* cur = pos._node;
        Node* prev = cur->_prev;
		Node* newnode = new Node(val);


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

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

		return iterator(newnode);
	}

	void push_back(const T& x){
		insert(end(), x);
	}

	void push_front(const T& x){
		insert(begin(), x);
	}

（2）删除节点首先定义一个临时指针将要删除的节点保存下来 ，然后修改前后节点的指针指向 ，最后删除节点 ，返回删除节点的下一个节点。

cpp 复制代码 
	iterator erase(iterator pos){
		assert(pos != end());

		Node* del = pos._node;
		Node* prev = del->_prev;
		Node* next = del->_next;

		prev->_next = next;
		next->_prev = prev;
		delete del;
		return iterator(next);
	}	
    void pop_front(){
		erase(begin());
	}
	void pop_back(){
		erase(--end());
	}

3.4 结合实例深入剖析

我们使用下面这段代码结合调试来深入剖析list容器

cpp 复制代码 
int main()
{
	henu::list<int> lt1;
	lt1.push_back(1);
	lt1.push_front(2);
	lt1.pop_back();
	lt1.pop_front();
	
	for (auto e : lt1)
	{
		cout << e << " ";
	}
	return 0;
}

3.4.1构造 lt1

当程序运行到henu::list<int> lt1;时，程序会跳转到henu::list中的list构造函数来构造lt1

_head申请一个新的节点空间，这里会调用list_node的构造函数将_head初始化

最后完成节点指针的指向，这样lt1节构造完成了，此时lt1中只有一个_head哨兵节点

3.4.2 尾插头插

将1尾插到lt1中，调用push_back

调用Insert，因为是传递end()作为位置参数来插入元素，因此end（）会在每次调用push_back时先被构造，然后再调用insert

调用iterator end（），返回指向链表尾部哨兵节点的 迭代器

调用insert（）

调用list_node，申请一个新的节点

将该节点初始化

完善指针指向，最后返回一个指向新插入节点的迭代器，因此调用iterator将新节点构造为一个迭代器。list迭代器的*、->、++、--等操作是在list_iterator中特殊实现的，因此需要用iterator构造新节点，该节点才能使用迭代器的*、->、++、--等操作。

生成一个指向一个新节点的迭代器。

最后返回，尾插完成

头插与尾插过程相似

3.4.3 头删尾删

调用pop_front方法头删

因为参数是一个迭代器，所以先构造begin（），再调用erase

调用list_iterator将要返回的节点构造为一个迭代器，指向链表的第一个节点

调用erase方法，在assert中，先构造end（），再判断!=

构造end（），返回一个指向end（）的迭代器，确保传入的pos不等于end（）

判断pos和end（）是否相等

完成指针指向，返回删除节点的下一个节点的迭代器

尾删和头删类似

5.完整代码

cpp 复制代码 
#include "list.h"

int main()
{
	henu::list<int> lt1;
	lt1.push_back(1);
	lt1.push_front(2);
	lt1.pop_front();
	lt1.pop_back();

	return 0;
}
cpp 复制代码 
#pragma once
#include<iostream>
#include<algorithm>
#include "list.h"
using namespace std;
#include <assert.h>

namespace henu
{
	template <class T>
	struct list_node
	{
		T _data;
		list_node<T>* _next;
		list_node<T>* _prev;

		list_node(const T& x = T())
			:_data(x)
			,_next(nullptr)
			,_prev(nullptr)
		{}
	};
	template <class T, class Ref, class Ptr>
	struct list_iterator
	{
		typedef list_node<T> Node;
		typedef list_iterator<T, Ref, Ptr> iterator;
		Node* _node;

		list_iterator(Node* node)
			:_node(node)
		{}

		Ref operator*()
		{
			return _node->_data;
		}

		Ptr operator->()
		{
			return &_node->_data;
		}

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

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

		//前置
		iterator& operator++()
		{
			_node = _node->_next;
			return *this;
		}

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

		bool operator!=(const iterator& s)
		{
			return _node != s._node;
		}

		bool operator==(const iterator& s)
		{
			return _node == s._node;
		}

	};

	template <class T>
	class list
	{
		typedef list_node<T> Node;
	public:
		typedef list_iterator<T, T&, T*> iterator;
		typedef list_iterator<T, const T&, const T*> const_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);
		}

		void empty_init()
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}

		list()
		{
			empty_init();
		}
		list(const list<T>& lt)
		{
			empty_init();

			for (auto& e : lt)
			{
				push_back(e);
			}
		}

		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}
		void swap(list<T>& tmp)
		{
			std::swap(_head, tmp._head);
			std::swap(_size, tmp._size);
		}
		list(size_t n, const T& val = T())
		{
			empty_init();
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}
		~list()
		{
			clear();

			delete _head;
			_head = nullptr;
		}
		void clear()
		{
			auto it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
		iterator insert(iterator pos, const T& val)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(val);
			Node* prev = cur->_prev;

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

			newnode->_next = cur;
			cur->_prev = newnode;
			++_size;

			return iterator(newnode);
		}
		void push_back(const T& x)
		{
			//Node* newnode = new Node(x);
			//newnode->_next = _head;
			//newnode->_prev = _head->_prev;

			//_head->_prev->_next = newnode;
			//_head->_prev = newnode;
			insert(end(), x);
		}
		void push_front(const T& x)
		{
			insert(begin(), x);
		}
		void pop_front()
		{
			erase(begin());
		}
		void pop_back()
		{
			erase(--end());
		}

		iterator erase(iterator pos)
		{
			assert(pos != end());

			Node* del = pos._node;
			Node* prev = del->_prev;
			Node* next = del->_next;

			prev->_next = next;
			next->_prev = prev;
			delete del;
			--_size;
			return iterator(next);
		}

	private:
		Node* _head;
		size_t _size;
	};
	template <class T>
	void swap(T& a, T& b)
	{
		T c(a); a = b; b = c;
	}

	template <class T>
	void swap(list<T>& a, list<T>& b)
	{
		a.swap(b);
	}
}
相关推荐
Geometry Fu6 分钟前
二叉树删除子树 （题目分析+C++代码实现）
数据结构·算法·图论
一缕叶14 分钟前
P8772 [蓝桥杯 2022 省 A] 求和
数据结构·c++·算法
菜还不练就废了16 分钟前
蓝桥杯c/c++需要掌握的基础语法总结
c语言·c++·蓝桥杯
轩情吖23 分钟前
C++模拟实现queue
开发语言·c++·后端·容器·stl·队列·queue
快敲啊死鬼34 分钟前
王道数据结构day1
数据结构
是阿建吖!41 分钟前
【Linux】多线程（二）
linux·c语言·c++
轩情吖1 小时前
C++模拟实现stack
开发语言·c++·后端·容器·栈·stack
欢天喜地小姐姐2 小时前
ubuntu16.04 VSCode下cmake+clang+lldb调试c++
c++·vscode
手心里的白日梦7 小时前
多线程杂谈：惊群现象、CAS、安全的单例
c++
Frenemy__8 小时前
快速排序练习
数据结构
热门推荐
01Windows10安装PCL1.14.0及点云配准02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)04Dell服务器升级ubuntu 22.04失败解决05密码学原理技术-第六章-introduction to pulibc-key cryptography06优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间07leetcode - 1769. Minimum Number of Operations to Move All Balls to Each Box08centos7 init.d 和system.d09渗透测试之SQLMAP工具详解 kali自带SQLmap解释 重点sqlmap --tamper 使用方式详解 搞完你就很nice了10小米路由器简单救砖