C++ List底层实现

最新推荐文章于 2024-07-09 20:53:03 发布
最新推荐文章于 2024-07-09 20:53:03 发布
阅读量1.1k 收藏 10
点赞数 21
分类专栏： C嘎嘎 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lim6ere/article/details/136818154
版权

文章目录

前言

我们都清楚c++中的容器list，本质上就是一个带头双向循环链表，接下来我们实现一下list的底层，帮助我们更深层次的了解list的结构和使用

成员变量

我们知道这个节点有三部分构成 _prev,_next,_val;每个节点看作list的一个元素，这又是一个双向带头循环链表，那么我们如果仅仅知道头节点，就可以访问遍历链表中的所有元素。

//类模板
template < class T>
struct ListNode
{
ListNode(const T& val=T()) //初始化
:_prev(nullptr)
,_next(nullptr)
,_data(val)
{ }
ListNode* _prev;//指向前一个元素
ListNode* _next;//指向后一个元素
T _data;//当前节点的值
};

有了这个结点之后，我们在实现list是创建一个头节点就可以控制这个链表了

template
class list
{
    //模板+类–》类型
    typedef ListNode Node;
private:
    Node* _head;
};

在class类中，默认为私有的，在struct中默认为公有，只有将这个节点定义为公有，我们才可以访问。

那这里采用内部类的方法不行吗？？
答案是不行的，如果我们吧struct定义在内部类中，外部list类就无法访问struct中的元素了。

成员函数

迭代器

我们在实现vector中，迭代器我们并没有实现，或者说我们不需要实现，因为vector容容器的结构很特殊，是一块连续的物理空间。加加，解引用等方式很容易实现。

我们看一下迭代器，是一个个地址不连续的指针
在这里插入图片描述

那我们怎末实现呢
我们很清楚迭代器的实质就是一个指针，在这个list中就是哟个listNode的指针。
我们要实现迭代器的操作，可以采用运算符重载的方式实现，但是这里又出现了新的问题，迭代器是一个内置类型，只有自定义类型才可以实现自定义类型重载，所以我们需要都这个指针进行封装，变成一个自定义类型

template< class T >
struct ___list_iterator
{
  typedef ListNode< T> Node;//方便我们使用
  typedef ___list_iterator< T> self;//方便使用，我们会用到
  ___list_iterator(Node* x)//初始化
    :_node(x)
    {}
  Node* _node;//成员变量
};

在这里面实现我们需要的功能，

list::const_iterator it = lt.begin();
while (it != lt.end())
{
std::cout << *it << " ";
++it;
}
std::cout << std::endl;

我们需要实现前置++,后置++,前置- -，后置- -，解引用，判断是否相等。我们依此来看一下

self& operator++()前置++

self& operator++()//++返回的是一个
{
   _node = _node->_next;//我们仅需要让指针往后移动一个节点就可以
  return *this;
}

self operator++(int)后置++

这里只能用self,不能用self&，因为返回的是一个临时对象
self operator++(int)//后置++也是返回一个节点，
{
  self tmp(*this);//首先拷贝一份
  _node = _node->next;//指针向后移动一个节点
  return tmp;//返回拷贝的值
}

self operator–()前置–

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

self operator–(int)后置–

self operator–(int)
{
  self tmp(*this);
   _node = _node->perv;
   return tmp;
}

bool operator!=(const self & tmp)判断是否相等

bool operator!=(const self & tmp)
{
   return _node != tmp._node;//判断两个指针是否指向同一块空间就可以
}

T* operator*() 解引用操作

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

list()初始化

list()
{
   我们初始化仅仅初始化头节点就可以
   empty_list();//我们可以通过调用这个函数创建头节点
}
void empty_list()
{
   _head = new Node;
   _head->_next = _head;
   _head->_prev = _head;
}

iterator begin()

iterator begin()
{
   return _head->_next;//第一个元素就是头节点后面的那个元素
}

iterator end()

iterator end()
{
   return _head;//最后一个元素的下一个就是head
}

const_iterator begin()const

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

const_iterator end()const

const_iterator end()const
{
   return _head;
}

iterator insert(iterator pos, const T& val)在pos位置插入val

iterator insert(iterator pos, const T& val)
{
   Node* cur = pos._node;//我们首先需要取到迭代器中的元素
   Node* newnode = new Node(val);//创建新节点
   Node* prev = cur->_prev;//保留之前的节点
   prev->_next = newnode;//改变指向
   newnode->_prev = prev;
   newnode->_next = cur;
   cur->_prev = newnode;
   return newnode;//返回新节点
}

在这里插入图片描述
我们来看一下这里的insert有没有迭代器失效的问题？？

void push_back(const T& val)在尾部位置后插入

void push_back(const T& val)
{
   insert(end(), val);//我们可以直接进行复用
}

void push_front(const T& val)在头部位置插入

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

iterator erase(iterator pos)

iterator erase(iterator pos)
{
   assert(pos != end());//断言一下，不是删除头节点
   Node* cur = pos._node;//取到迭代器中的元素
   Node* prev = cur->_prev;//记录前一个位置
   Node* next = cur->_next;//记录后一个位置
   delete cur;//释放当前元素
   prev->_next = next;//改变指向
   next->_prev = prev;
   return next;//返回删除元素的下一个位置
}

我们来看一下这里会不会有迭代器失效的问题??
我们发现这里存在迭代器失效的问题，并且很大，这个元素删除了之后，之后很可能还需要用到这个元素，继续删除，如果不及时更新，就会出现大问题。

void pop_back()//删除最后一个元素

void pop_back()
{
   erase(–end());//我们要注意end是哪个位置
}

void pop_front()删除第一个元素

void pop_front()
{
   erase(begin());
}

list(list& tmp)拷贝构造

在这里我们有很多方式实现，我们来看一种比较简单的
list(list< T>& tmp)
{
   empty_list();//首先创建一个头节点
   //遍历
   for (const auto& e : tmp)
   {
   push_back(e);//取数据依次插入这个新的头结点中
   }
}

void swap(list&tmp)交换两个list

void swap(list< int>&tmp)
{
   std::swap(_head, tmp._head);//我们仅仅改变两个list的指针就可以
}

list< T>& operator=(list< T> it)赋值

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

我们再来看一下这个过程，我们假设lt1=lt2;
因为list< T> it这里，lt2会产生一份临时拷贝it
在这里插入图片描述
我们swap(it)，本质就是将it与lt1的内容进行交换
在这里插入图片描述
it是临时变量，出了作用域就销毁了，我们就完成了赋值任务

int size()判断有多少元素

int size()
{
   int count = 0;//记录一个变量，一个个统计即可
   for (const auto& e : *this)
   {
   count++;
   }
   return count;
}

bool empty() 判断list是否为空

bool empty()
{
   return size() == 0;//我们只需要判断list是否有元素
}

T& front()取首元素

T& front()
{
   return _head->_next->_data;
}

T& back()取尾元素

T& back()
{
   return _head->_prev->_data;
}

void clear()清空元素

一个个删除元素即可
void clear()
{
   iterator it = begin();
   while (it != end())
   {
   it = erase(it);
   }
}

~list()析构

~list()
{
   clear();
   delete _head;
   _head = nullptr;
}

再谈迭代器

我们已经实现了普通迭代器，但是对于const都迭代器，我们还需要实现。
我们再来看一下const迭代器，并不是这个迭代器指针不可以修改，而是迭代器指针所指向的内容不可以修改。
那我们是不是可以在普通迭代器的基础上再新增一个const迭代器，我们仅需要修改解引用的那块操作就可以，其他实现的功能都是相同的。

template<class T >
struct ___list_const_iterator
{
	typedef ListNode<T>  Node;
	typedef ___list_const_iterator<T> self;
	___list_const_iterator(Node* x)
		:_node(x)
	{}
	//不等于
	bool operator!=(const self& tmp)
	{
		return _node != tmp._node;
	}
	//解引用
	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->perv;
		return tmp;
	}
	//需要返回一个地址
	T* operator->()
	{
		return &_node->_data;
	}

	Node* _node;
};

虽然这样可以完成我们的功能，但是总感觉代码有点冗余，const迭代器和普通迭代器有太多重复内容，那我们可不可以通过一种方法将这两种迭代器进行合并呢？？

我们来看一下！！！
我们注意到，const T& operator*()和T& operator*()仅仅是返回值不同，我们又不能把两个方法放在同一个迭代器中，我们可以利用传参的方式进行解决，我们来看一下这种操作
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

模板传递的是类型，根据传参的不同调用自己合适的模板参数，这两个是完全不同的类型，我们这样就可以轻松完成我们的工作，仅仅使用一个迭代器就完成了两个功能

完整代码

namespace peng
{
	template <class T>
	struct ListNode
	{
		ListNode(const T& val=T())
			:_prev(nullptr)
			,_next(nullptr)
			,_data(val)
		{	}
		ListNode* _prev;
		ListNode* _next;
		T _data;
	};
	//
	//迭代器
	//不连续,
	template<class T,class Ref  >
	struct ___list_iterator
	{
		typedef ListNode<T>  Node;
		typedef ___list_iterator<T,Ref> self;
		___list_iterator(Node* x)
			:_node(x)
		{}
			//不等于
			bool operator!=(const self & tmp)
			{
				return _node != tmp._node;
			}
			//解引用
			Ref 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->perv;
				return tmp;
			}
			//需要返回一个地址
			T* operator->()
			 {
				return &_node->_data;
				
			 }
		
	    Node* _node;
	};


	//默认私有
	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 ___list_iterator<T,T&> iterator;
		typedef ___list_iterator<T,const T&>  const_iterator;

		list()
		{			empty_list();
		}
		void empty_list()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
		}
		//l1(l2)
		list(list<T>& tmp)
		{
			empty_list();
			//遍历
			for (const auto& e : tmp)
			{
				push_back(e);
			}
		}
		iterator begin()
		{
			return _head->_next;
		}
		iterator end()
		{
			return _head;
		}
		const_iterator begin()const
		{
			return _head->_next;
		}
		const_iterator end()const
		{
			return _head;
		}
		void swap(list<int>&tmp)
		{
			std::swap(_head, tmp._head);
		}
		list<T>&  operator=(list<T> it)
		{
			swap(it);
			return *this;
		}
		int size()
		{
			int count = 0;
			for (const auto& e : *this)
			{
				count++;
			}
			return count;
		}
		bool empty()
		{
			return size() == 0;
		}
		iterator insert(iterator pos, const T& val)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(val);
			Node* prev = cur->_prev;
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			return newnode;
		}
		void push_back(const T& val)
		{
			insert(end(), val);
		}
		void push_front(const T& val)
		{
			insert(begin(), val);
		}
		iterator erase(iterator pos)
		{
			assert(pos != end());
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;
			delete cur;
			prev->_next = next;
			next->_prev = prev;
			return next;
		}
		T& front()
		{
			return _head->_next->_data;
		}
		T& back()
		{
			return _head->_prev->_data;
		}
		void pop_back()
		{
			erase(--end());
		}

		void pop_front()
		{
			erase(begin());
		}
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
	private:
		Node* _head;
	};
}

总结

以上就是今天要讲的内容，本文仅仅详细介绍了C++list的模拟实现，希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘

lim 鹏哥
关注
专栏目录
C++ List容器的底层实现
TABE_的博客
04-11 1852
这里写目录标题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 1129
目录一、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_70485831的博客
07-09 1025
链表中的数据和前后指针的类型都是模板生成的，可以适配内置类型和自定义类型。这里用struct来定义类的原因是struct默认的成员变量类型都是public，其他函数可以很方便的进行调用。在这里还有一个list_node的构造函数 T()是一个匿名变量，其作用不止是用于存放数据，此外如果调用list_node构造函数时没有写参数的话，这里也会有一个默认的值。在list中，有两个成员变量的存在一个是节点类型的指针_node 和计算节点数量的_size。
C++list简单底层实现代码
weixin_58666778的博客
04-10 1191
#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原理讲解及其实现
2201_76005883的博客
05-12 530
要模拟实现list，必须要熟悉list的底层结构以及其接口的含义，在上一篇我们仔细讲解了list的常见接口的使用及其含义，这篇我们就直接进入主题。
list的讲解及模拟实现(c++)
weixin_49312527的博客
05-08 2399
与介绍vector时相同为了方便大家理解, 我们采用便模拟实现便讲解使用方式的方式, 展开对list容器的讲解. 一.list的介绍 使用时注意包含头文件: #include<list> list相关特性介绍: 1.list的底层是一个带头结点的双向循环链表. 2.list是可以在常数范围内在任意位置进行插入和删除的序列式容器, 并且该容器可以前后双向迭代. 3.list的底层是双向链表结构, 双向链表中每个元素存储在互不相关的独立节点中, 在节点中通过指针指向其前一个元素..
list底层实现
a1912157861的博客
08-15 1284
list底层实现默认构造函数运算符重载增删改查操作 默认构造函数 一. 首先我们知道list的底层是用链表实现的，和vector在存储方式上有很大的不同，vector是地址连续存储的，而链表是通过指针来讲不连续的地址进行连接，所以我们要先创建一个类来表示链表类型，如下图: 此处创建了一个当前类的构造函数是为了之后其他类调用此类的时候直接对其进行初始化。 二. 在前面我们说过我们暂且可以将迭代器理解成指针，因为之前的vector和string类都是以连续空间的方式进行存储的，所以其迭代器中的++操作可以直接
模拟实现list超详解（C++）
m0_67430750的博客
04-25 3233
简易版list模拟实现超详解
【C++】list的使用及底层实现原理
weixin_67596609的博客
07-17 2451
本篇文章对list的使用进行了举例讲解。同时也对底层实现进行了讲解。底层的实现关键在于迭代器的实现。希望本篇文章会对你有所帮助。list底层实现关键是迭代器的实现。我们要清楚的是，list的迭代器底层就是一个对节点进行封装的类。初学可能会感觉有点难以理解。但是，应多看几遍理解整体结构就很容易清楚了。
c++list类实现
11-23
1）代码注释很详细的，非常适合学习STL的。 2）数据结构里面两种非常重要的存储结构，线性结构中的连续存储结构（代表vector数组）和非连续存储结构（代表list链表），他们两者被广泛的应用在各个领域，是最基本最基础的两种存储结构； 3）之前的友元类只是停留在理论层面，真正实现还是头一次；友元类非常像java中的内部类
C++ 使用模板实现一个List的实例
08-30
主要介绍了 C++ 使用模板实现一个List的实例的相关资料,需要的朋友可以参考下
c++stl 之list的底层理解及其模拟实现
qq_54626677的博客
01-09 453
前面说过，此处大家可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。此处，大家可暂时将迭代器理解成一个指针，该指针指向list中的某个节点。
[STL]list的底层实现
这是书生呀
05-14 462
在看底层代码之前我们需要了解几个问题 问题一：STL链表是一个什么结构？ STL链表是一个双向循环链表。 问题二： 那么list类中怎么构建这样的一个双向链表呢？ 先构建一个无任何作用的头结点，如果链表需要新增节点，那么只需要插入即可 问题三： 解决完链表的构造，那么另一个重要的问题：迭代器的实现 我们知道迭代器支持前置++ 、- -、后置++ 、- -以及解引用、->等等、* 对于string、vector等容器、迭代器可以看作一个指针； ++、- -等只需要指针进行++ 、–进行前后移动即可 。
C++List详解
m0_53889456的博客
05-11 7384
list容器详解，学我这一篇就够了。你写的C++list到底有什么不一样？都让人写烂的东西了你怎么还写？你比别人强？点进来看看你就知道有什么不一样了。
c++|list使用及深度剖析模拟实现
weixin_68201503的博客
04-15 1212
①list底层是带头双向循环链表，在任意位置可进行插入和删除的序列式容器。②list与其他序列式容器相比(array,vector,deque),list通常在任意位置进行插入、移除元素的执行效率更好。③与其他序列式容器相比，list的缺陷是不支持任意位置的随机访问，要访问某个元素，必须从已知位置迭代到访问位置，这段迭代则需要额外的线性时间开销，途中，还需要开辟额外空间，来保存每个节点的相关联信息。
C++--list简单实现
weixin_66828150的博客
07-18 726
vector:为动态顺序表，支持随机访问，空间利用率高，为原生指针，底层直接使用指针进行指针的加加，在插入元素时，要给所有的迭代器重新赋值，因为插入元素有可能会导致重新扩容，致使原来迭代器失效，删除时，当前迭代器需要重新赋值否则会失效。list: 为链式存储，不支持随机访问，空间利用率不高，为原生指针的封装，在插入元素使，迭代器不会失效，但在删除元素是，迭代器需要重新赋值，否则会失效，多应用于大量插入和删除操作，不关心随机访问。ps:要模拟实现list，必须要熟悉list的底层结构以及其接口的含义。
C++ list容器的实现及讲解
2201_75324712的博客
09-24 520
对C++类的基本了解 默认构造函数 操作符重载 this指针 引用 模板等知识具有一定的了解，阅读该文章会很轻松。
C++入门篇(13)之list的实现
m0_51723227的博客
11-24 4207
文章目录前言list的结构搭建两种构造函数① 默认构建函数② 迭代器区间构建函数拷贝构造函数赋值重载数据的头尾删插① 尾插push_back()② 尾删pop_back()③ 头插push_front()④ 头删pop_front()迭代器的实现迭代器接口clear()清理析构函数erase和insert的实现and简化头尾数据删除最终list代码 前言 上一节我们简单叙述了一下list的概念,知道其底层是一个带头结点的双向循环链表,并且介绍了其使用方法,**但是!**知其然未必知其所以然,我们不但应该知其
c++list底层原理
07-31
回答: 在C++中，list是一种双向链表的容器。它的底层原理是通过使用指针将各个节点连接起来形成链表结构。每个节点包含一个值和两个指针，一个指向前一个节点，一个指向后一个节点。list的构造函数有多种形式，包括拷贝构造、以n个val初始化构造和区间构造。拷贝构造函数会创建一个新的链表，并将另一个链表中的元素复制到新链表中。以n个val初始化构造函数会创建一个包含n个相同值的链表。区间构造函数会根据指定的迭代器范围，在新链表中复制指定范围内的元素。这些构造函数的实现细节可以参考引用[1]、[2]和[3]中的代码片段。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

lim 鹏哥

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

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

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

打赏作者

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

抵扣说明：

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

余额充值