C++ STL-List源码分析

最新推荐文章于 2024-05-26 17:26:56 发布
最新推荐文章于 2024-05-26 17:26:56 发布
阅读量2.2k 收藏 34
点赞数 9
分类专栏： C++ 文章标签： c++ STL 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50886514/article/details/116090940
版权

文章目录：

STL-List-源码

List源码可查看—>[List源码]

1. 对私有成员的数据类型进行声明

源码中私有成员如下：

在这里插入图片描述

刨析后如下：

#include<iostream>
using namespace std;

namespace code
{
	template <class _Ty>
	class list
	{
	public:
		//类型的萃取
		typedef size_t size_type;//大小的类型
		typedef _Ty    value_type;//值类型
		typedef _Ty*   pointer_type;//指针类型
		typedef _Ty&   reference_type;//引用类型
		typedef const _Ty* const_pointer_type;//常指针类型
		typedef const _Ty& const_reference_type;//常引用类型
	public:
		struct _Node;
		typedef struct _Node* _Nodeptr;
	private:
		_Nodeptr _Head;
		size_type _Size;
	};
}

void main()
{
	code::list<int>mylist;
}

2. 初始化，写入构造函数，申请一个头节点，

相关源码如下：
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

刨析如下：

#include<iostream>
using namespace std;

namespace code
{
	template <class _Ty>
	class list
	{
	public:
		//类型的萃取
		typedef size_t size_type;//大小的类型
		typedef _Ty    value_type;//值类型
		typedef _Ty*   pointer_type;//指针类型
		typedef _Ty&   reference_type;//引用类型
		typedef const _Ty* const_pointer_type;//常指针类型
		typedef const _Ty& const_reference_type;//常引用类型
	public:
		struct _Node;
		typedef struct _Node* _Nodeptr;
		struct _Node
		{
			_Nodeptr _Next;
			_Nodeptr _Prev;
			_Ty    _value;
		};

		struct _Acc
		{
			typedef struct _Node* & _Nodepref;
			typedef _Ty&     _Vref;
			static _Nodepref _Next(_Nodeptr _P)
			{
				return (_P->_Next);
			}
			static _Nodepref _Prev(_Nodeptr _P)
			{
				return (_P->_Prev);
			}
			static _Vref _Value(_Nodeptr _P)
			{
				return (_P->_Value);
			}
		};

	//刨析写法一：

	//public:
	//	explicit list() :_Head(nullptr), _Size(0)
	//	{
	//		_Head = new _Node;
	//		_Head->_Next = _Head;
	//		_Head->_Prev = _Head;
	//	}

	//刨析写法二
	
	//public:
	//	explicit list() :_Head(_Buynode()), _Size(0)
	//	{}
	//protected:
	//	_Nodeptr _Buynode(_Nodeptr _Narg = 0, _Nodeptr _Parg = 0)
	//	{
	//		_Nodeptr _S = new _Node;
	         //申请完节点可以直接连接它的前驱和后继
	//		_S->_Next = _Narg != 0 ? _Narg : _S;
	//		_S->_Prev = _Parg != 0 ? _Parg : _S;

	//		return _S;
	//	}

		//源码写法，封装性更好，不会让成员暴露
		public:
			explicit list() :_Head(_Buynode()), _Size(0)
			{}
		protected:
			_Nodeptr _Buynode(_Nodeptr _Narg = 0, _Nodeptr _Parg = 0)
			{
				_Nodeptr _S = new _Node;
				_Acc::_Next(_S) = _Narg != 0 ? _Narg : _S;
				_Acc::_Prev(_S) = _Parg != 0 ? _Parg : _S;

				return _S;
			}


	private:
		_Nodeptr _Head;
		size_type _Size;
	};
}

void main()
{
	code::list<int>mylist;
}

如上三种写法的效果是一样的，但源码的写法不会将成员暴露出来，相对更好

测试效果如下：
在这里插入图片描述

3.尾插

相关源码如下：
在这里插入图片描述
刨析后数据结构写法如下：

	    public:
			void push_back(const _Ty& _X)
			{
				_Nodeptr _S = new _Node;
				_S->_Value = _X;
				_S->_Prev = _Head->_Prev;
				_S->_Next = _Head;
				_Head->_Prev = _S;
				_S->_Prev->_Next = _S;
				++_Size;
			}

优化后如下：

			//尾插
	    public:
			void push_back(const _Ty& _X)
			{
				_Nodeptr _S = _Buynode(_Head, _Acc::_Prev(_Head));
				_Acc::_Value(_S) = _X;
				_Acc::_Next(_Acc::_Prev(_S)) = _S;
				_Acc::_Prev(_Acc::_Next(_S)) = _S;
				++_Size;
			}

4. 构造迭代器

给一个私有成员变量_Ptr(一个指针)，写出迭代器的默认构造函数

	public:
		//构造一个迭代器
		class iterator
		{
		public:
			iterator()
			{}
			iterator(_Nodeptr _P) :_Ptr(_P)
			{}
		private:
			_Nodeptr _Ptr;
		};

写一个begin()构造器，返回第一个真实节点；一个end()构造器，返回头节点

	public:
		//begin()迭代器 返回第一个真实节点
		iterator begin()
		{
			return iterator(_Acc::_Next(_Head));
		}
		//end()迭代器 返回头节点
		iterator end()
		{
			return iterator(_Head);
		}

重载++，–，*，!=，==

源码如下：
在这里插入图片描述

刨析后写法如下：

	public:
		//构造一个迭代器
		class iterator
		{
		public:
			iterator()
			{}
			iterator(_Nodeptr _P) :_Ptr(_P)
			{}
		public:
			//不等号重载
			bool operator!=(const iterator& _it)
			{
				return _Ptr != _it._Ptr;
			}
			//等号重载
			bool operator==(const iterator& _it)
			{
				return _Ptr == _it._Ptr;
			}
			//*的重载
			_Ty& operator*()
			{
				return _Acc::_Value(_Ptr);
			}
			//前置++的重载
			iterator& operator++()
			{
				_Ptr = _Acc::_Next(_Ptr);
				return *this;
			}
			//后置++的重载
			iterator operator++(int)
			{
				iterator tem(_Ptr);
				++*this;
				return tem;
			}
			//前置--的重载
			iterator& operator--()
			{
				_Ptr = _Acc::_Prev(_Ptr);
				return *this;
			}
			//后置--的重载
			iterator operator--(int)
			{
				iterator tmp(_Ptr);
				--*this;
				return tmp;
			}
		private:
			_Nodeptr _Ptr;
		};

打印测试：

void main()
{
	code::list<int>mylist;
	mylist.push_back(1);
	mylist.push_back(2);
	mylist.push_back(3);

	code::list<int>::iterator it = mylist.begin();
	while (it != mylist.end())
	{
		cout << *it << "->";
		++it;
	}
	cout << "end" << endl;
}

测试效果如下：
在这里插入图片描述

5. 插入一个节点到_P位置

写入一个插入函数insert
源码如下：

在这里插入图片描述

刨析后代码如下：

	//数据结构写法

		//public:
		//	//指定一个位置进行插入
		//	iterator insert(iterator _P, const _Ty& _X = _Ty())
		//	{
		//		_Nodeptr _S = new _Node;
		//		_Acc::_Value(_S) = _X;
		//		
		//		_Nodeptr _N = _P._Mynode();
		//		_S->_Next = _N;
		//		_S->_Prev = _N->_Prev;
		//		_S->_Prev->_Next = _S;
		//		_S->_Next->_Prev = _S;
		//		++_Size;
		//		return iterator(_S);
		//	}

		public:
			iterator insert(iterator _P, const _Ty& _X = _Ty())
			{
				//_S指向_P位置
				_Nodeptr _S = _P._Mynode();
				//新节点连向它的后继和前驱，_P连接新节点
				_Acc::_Prev(_S) = _Buynode(_S, _Acc::_Prev(_S));
				//_S指向新节点
				_S = _Acc::_Prev(_S);
				//_S的前驱的后继指向_S
				_Acc::_Next(_Acc::_Prev(_S)) = _S;
				_Acc::_Value(_S) = _X;
				++_Size;
				return (iterator(_S));
			}

此时头插尾插可以优化为：

		//尾插
		void push_back(const _Ty& _X)
		{
			insert(end(), _X);
		}
		//头插
		void push_front(const _Ty& _X)
		{
			insert(begin(), _X);
		}

6. 判空

返回_Size的大小判断是否为0

在这里插入图片描述

7. 取链表的第一个节点

此处有两个方法一个针对普通对象，一个针对常对象

在这里插入图片描述

8. 取链表的尾节点(需- -)

end()取的是最后一个节点的下一个位置(_Head)

在这里插入图片描述

9. 三种构造函数

（1）默认构造函数（2）初始化为n个x（3）初始化一个区间

源码如下：
在这里插入图片描述

刨析如下：

        //默认构造函数
	    explicit list():_Head(_Buynode()),_Size(0)
		{}
		//初始化为n个x
		list(size_type _N, const _Ty& _V = _Ty())
			:_Head(_Buynode()), _Size(0)
		{
			insert(begin(), _N, _V);
		}
		//初始化一个区间
		list(const _Ty *_F, const _Ty *_L)
			:_Head(_Buynode()), _Size(0)
		{
			insert(begin(), _F, _L);
		}

10. 删除节点

		//删除节点
			iterator erase(iterator _P)
			{
				_Nodeptr _S = (_P++)._Mynode();
				_Acc::_Next(_Acc::_Prev(_S)) = _Acc::_Next(_S);
				_Acc::_Prev(_Acc::_Next(_S)) = _Acc::_Prev(_S);
				_Deletenode(_S);
				--_Size;
				return (_P);
			}
			//删除一个区间
			iterator erase(iterator _F, iterator _L)
		    {
			    while (_F != _L)
			   	erase(_F++);
			    return (_F); 
		    }
		    //清除函数
		    void clear()
		    {
		    	erase(begin(), end());
		    }
			protected:
			void _Deletenode(_Nodeptr _S)
			{
				delete _S;
			}

11. 最终刨析代码

#include<iostream>
using namespace std;

namespace code
{
	template <class _Ty>
	class list
	{
	public:
		//类型的萃取
		typedef size_t size_type;//大小的类型
		typedef _Ty    value_type;//值类型
		typedef _Ty*   pointer_type;//指针类型
		typedef _Ty&   reference_type;//引用类型
		typedef const _Ty* const_pointer_type;//常指针类型
		typedef const _Ty& const_reference_type;//常引用类型
	public:
		struct _Node;
		typedef struct _Node* _Nodeptr;
		struct _Node
		{
			_Nodeptr _Next;
			_Nodeptr _Prev;
			_Ty    _Value;
		};

		struct _Acc
		{
			typedef struct _Node* & _Nodepref;
			typedef _Ty&     _Vref;
			static _Nodepref _Next(_Nodeptr _P)
			{
				return (_P->_Next);
			}
			static _Nodepref _Prev(_Nodeptr _P)
			{
				return (_P->_Prev);
			}
			static _Vref _Value(_Nodeptr _P)
			{
				return (_P->_Value);
			}
		};
	public:
		//构造一个迭代器
		class iterator
		{
		public:
			iterator()
			{}
			iterator(_Nodeptr _P) :_Ptr(_P)
			{}
		public:
			//不等号重载
			bool operator!=(const iterator& _it)
			{
				return _Ptr != _it._Ptr;
			}
			//等号重载
			bool operator==(const iterator& _it)
			{
				return _Ptr == _it._Ptr;
			}
			//*的重载
			_Ty& operator*()
			{
				return _Acc::_Value(_Ptr);
			}
			//前置++的重载
			iterator& operator++()
			{
				_Ptr = _Acc::_Next(_Ptr);
				return *this;
			}
			//后置++的重载
			iterator operator++(int)
			{
				iterator tem(_Ptr);
				++*this;
				return tem;
			}
			//前置--的重载
			iterator& operator--()
			{
				_Ptr = _Acc::_Prev(_Ptr);
				return *this;
			}
			//后置--的重载
			iterator operator--(int)
			{
				iterator tmp(_Ptr);
				--*this;
				return tmp;
			}
			//返回Ptr指针
			_Nodeptr _Mynode()
			{
				return _Ptr;
			}
		private:
			_Nodeptr _Ptr;
		};

	//刨析写法一：

	//public:
	//	explicit list() :_Head(nullptr), _Size(0)
	//	{
	//		_Head = new _Node;
	//		_Head->_Next = _Head;
	//		_Head->_Prev = _Head;
	//	}

	//刨析写法二
	//public:
	//	explicit list() :_Head(_Buynode()), _Size(0)
	//	{}
	//protected:
	//	_Nodeptr _Buynode(_Nodeptr _Narg = 0, _Nodeptr _Parg = 0)
	//	{
	//		_Nodeptr _S = new _Node;
	//		_S->_Next = _Narg != 0 ? _Narg : _S;
	//		_S->_Prev = _Parg != 0 ? _Parg : _S;

	//		return _S;
	//	}

		//源码写法，封装性更好，不会让数据暴露
		public:
			//构造函数
			explicit list() :_Head(_Buynode()), _Size(0)
			{}
			list(size_type _N, const _Ty& _V = _Ty()):_Head(_Buynode()), _Size(0)
			{
				insert(begin(), _N, _V);
			}
			list(const _Ty *_F, const _Ty *_L)
				:_Head(_Buynode()), _Size(0)
			{
				insert(begin(), _F, _L);
			}
			//析构函数
			~list()
			{
				//erase(begin(), end());
				clear();
				_Deletenode(_Head);
				_Head = 0, _Size = 0;
			}
	  //  public:
			//void push_back(const _Ty& _X)
			//{
			//	_Nodeptr _S = new _Node;
			//	_S->_Value = _X;
			//	_S->_Prev = _Head->_Prev;
			//	_S->_Next = _Head;
			//	_Head->_Prev = _S;
			//	_S->_Prev->_Next = _S;
			//	++_Size;
			//}
	public:
		//begin()迭代器 返回第一个真实节点
		iterator begin()
		{
			return iterator(_Acc::_Next(_Head));
		}
		//end()迭代器 返回头节点
		iterator end()
		{
			return iterator(_Head);
		}
			尾插
	  //  public:
			//void push_back(const _Ty& _X)
			//{
			//	_Nodeptr _S = _Buynode(_Head, _Acc::_Prev(_Head));
			//	_Acc::_Value(_S) = _X;
			//	_Acc::_Next(_Acc::_Prev(_S)) = _S;
			//	_Acc::_Prev(_Acc::_Next(_S)) = _S;
			//	++_Size;
			//}

		//尾插
		void push_back(const _Ty& _X)
		{
			insert(end(), _X);
		}
		//头插
		void push_front(const _Ty& _X)
		{
			insert(begin(), _X);
		}

		//数据结构写法

		//public:
		//	//指定一个位置进行插入
		//	iterator insert(iterator _P, const _Ty& _X = _Ty())
		//	{
		//		_Nodeptr _S = new _Node;
		//		_Acc::_Value(_S) = _X;
		//		
		//		_Nodeptr _N = _P._Mynode();
		//		_S->_Next = _N;
		//		_S->_Prev = _N->_Prev;
		//		_S->_Prev->_Next = _S;
		//		_S->_Next->_Prev = _S;
		//		++_Size;
		//		return iterator(_S);
		//	}

		public:
			iterator insert(iterator _P, const _Ty& _X = _Ty())
			{
				//_S指向_P位置
				_Nodeptr _S = _P._Mynode();
				//新节点连向它的后继和前驱，_P连接新节点
				_Acc::_Prev(_S) = _Buynode(_S, _Acc::_Prev(_S));
				//_S指向新节点
				_S = _Acc::_Prev(_S);
				//_S的前驱的后继指向_S
				_Acc::_Next(_Acc::_Prev(_S)) = _S;
				_Acc::_Value(_S) = _X;
				++_Size;
				return (iterator(_S));
			}
			//删除节点
			iterator erase(iterator _P)
			{
				_Nodeptr _S = (_P++)._Mynode();
				_Acc::_Next(_Acc::_Prev(_S)) = _Acc::_Next(_S);
				_Acc::_Prev(_Acc::_Next(_S)) = _Acc::_Prev(_S);
				_Deletenode(_S);
				--_Size;
				return (_P);
			}
			void insert(iterator _P, size_type _M, const _Ty& _X)
			{
				for (; 0 < _M; --_M)
					insert(_P, _X);
			}
			void insert(iterator _P, const _Ty *_F, const _Ty *_L)
			{
				for (; _F != _L; ++_F)
					insert(_P, *_F);
			}
			//删除一个区间
			iterator erase(iterator _F, iterator _L)
			{
				while (_F != _L)
					erase(_F++);
				return (_F);
			}
			//清除函数
			void clear()
			{
				erase(begin(), end());
			}
			//申请节点
		protected:
			_Nodeptr _Buynode(_Nodeptr _Narg = 0, _Nodeptr _Parg = 0)
			{
				_Nodeptr _S = new _Node;
				_Acc::_Next(_S) = _Narg != 0 ? _Narg : _S;
				_Acc::_Prev(_S) = _Parg != 0 ? _Parg : _S;

				return _S;
			}
			void _Deletenode(_Nodeptr _S)
			{
				delete _S;
			}


	private:
		_Nodeptr _Head;
		size_type _Size;
	};
}

void main()
{
	code::list<int>mylist;
	mylist.push_back(1);
	mylist.push_back(2);
	mylist.push_back(3);
	//code::list<int>::iterator pos = mylist.begin();
	///*mylist.erase(pos);*/
	mylist.clear();
	code::list<int>::iterator it = mylist.begin();
	while (it != mylist.end())
	{
		cout << *it << "->";
		++it;
	}
	cout << "end" << endl;
}
双鱼211
关注
  • 9
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
STL-Boost:STL-Boost源码剖析
03-24
通过深入源码学习，开发者不仅可以提升对C++ STL和Boost库的理解，还能提高解决问题的能力，写出更加高效、可靠的代码。这是一项对专业程序员非常有价值的研究工作，能够帮助他们在面对复杂项目时做出更明智的设计...
STL--源码剖析完整版.zip
04-09
侯捷的《STL源码剖析》详细分析了STL的实现细节，包括容器的内存管理策略、迭代器的实现原理以及算法的优化技巧。通过阅读这本书，开发者可以理解STL如何通过模板元编程实现高效和灵活的代码，并学习到如何更有效地...
C++-list源码初探-个人理解&编写思路
weixin_43580319的博客
04-18 465
文章目录list源码剖析 list源码剖析 1.寻找源码中的私有成员变量，一个类中我们的所有的公有操作都是对私有成员变量进行操作的。 初步的写成的代码如下： #include <iostream> using namespace std; namespace my_list { template<class _Ty> class list { public: //类型的萃取 struct _Node; typedef struct _Node* _Nodept
C++ list 源码学习
weixin_30919571的博客
07-26 177
一. list 实例 #include<list> //调用系统的list,双向循环链表结构 using namespace std; int main(void) { list<int> mylist; for(int i = 1; i <= 10; i++) { ...
C++——list的实现以及源码
最新发布
zgwnb666的博客
05-26 730
C++——list的实现以及源码
C++ STL源码分析之 list
man_sion的博客
04-30 1929
STL中list与其他顺序容器实现不同因此不支持一部分容器操作，注：forward_list 有自己特有的insert 和emplace,vetor和string不支持push_front和emplace_front STL的list是一个双向链表，而且实现的是个环状双向链表，因此一个指针即可代表整个链表。 为了符合STL对于前闭后开的区间要求，node指针指向特意置于尾端的一个空白节点，以符
STL源码简述
不积跬步无以至千里
03-19 4921
STL简述。
STL（C++标准库，体系结构及其内核分析）（STL源码剖析）（更新完毕）
世界仙境与冷酷尽头's Blog
09-03 3997
STL（C++标准库，体系结构及其内核分析）（STL源码剖析）（更新完毕）
C++STL源码分析 SGI版
10-30
**C++ STL源码分析 SGI版** C++标准模板库（Standard Template Library，STL）是C++编程中不可或缺的一部分，它提供了高效且灵活的数据结构和算法。STL的实现有多种，其中SGI（Stanford Graphics Interface）版本以...
STL.rar_C++ STL_FSET-885_STL_stl源码_visual c
09-24
STL的源码分析对于深入理解其工作原理、优化代码性能以及自定义特殊功能都极其重要。Visual C++编译器通常会包含STL的实现，但查看源码可以帮助我们学习如何使用STL更高效地编写C++程序。 在这个"STL.rar"压缩包中...
c++stl标准库源码
12-07
c++ stl The Standard Template Library, 容器（Container） 迭代器（Iterator） 算法（Algorithm）仿函数（Function object）迭代适配器（Adaptor）空间配制器（allocator）
C++ STL源码详解
05-14
STL 源码解析，纯c++代码，对于希望了解STL里各个容器（如map，set, vector, queue等）的实现原理有很大帮助，希望能帮到大家。
SGI STL的源码
05-11
1.由于HPE收购了SGI，所以官网已无法下载SGI STL源码。2.Ubuntu16.04自带glibc版本是2.23
C++_STL源码阅读：三大底层序列容器 Vector List Deque
箫声清阳的空间
05-23 924
一 笨重的废话：容器是STL体系的重要支撑点，承上启下，下基于Allocator进行memory的分配与管理，形成一个个的容器，对上呢，支撑Iterator和各种Algorithms，所以，Container才是STL的核心。那么Container又分 序列式 + 关联式 两种；（跟 线性 vs 非线性 不是一个概念）；《STL源码剖析》是这么分类的；序列式容器中，有线性的特点，比较常见的是三大底...
C++ list最详细教程1 （包含程序源码）
勤天下而拥家
01-02 1015
/* list test demo time:2017.1.2在任何位置插入删除都是常数时间，不支持随机存取。除了具有所有顺序容器都有的成员函数以外，还支持8个成员函数： push_front: 在前面插入 pop_front: 删除前面的元素 sort: 排序( list 不支持STL 的算法sort) remove: 删除和指定值相等的所有元素 unique: 删除所有和前一个元素相同的元
c++ list 容器源码架构
w593942008的博客
04-18 410
using _Mybase = _List_buy<_Ty, _Alloc>; using iterator = typename _Mybase::iterator; 迭代器 迭代器类 ：_List_unchecked_const_iterator 、 _List_unchecked_iterator 、 List_const_iterator、class _List_iter...
C++ STL源码刨析 list篇（1）容器建立
qq_60567866的博客
03-09 878
新手对STL容器的源码剖析。 首先为什么要做源码刨析？甚至我也有很大的疑问，会用就好。但是事实上看了源码会让你对各个算法的运用和容器有了更深的认识，并且我们阅读大师级的源码不也是一个成长的过程吗。 提示： 命名方式： _Insert_after 当下划线出现在首部时，变量作为函数内部使用。 首先工具推荐使用VS2017以上的版本。 接下来我们一步步的实现list。 首先list是个双向的链表 1.定义list.h 知识点： explicit关键字 explicit关键...
stl源码分析list的sort()
cchao985771161的博客
07-06 245
#include #include #include typedef std::list IList; void print(const IList& list) { IList::const_iterator it = list.begin(); for(; it != list.end(); ++it) std::cout<<*it<<" "; std...
C++STL源码分析
09-13
对于C++ STL的源码分析，这是一个广泛而复杂的话题。C++ STL是C++标准库中的一部分，包含了许多不同的容器、算法和迭代器等组件，用于提供通用的数据结构和算法支持。 在进行源码分析之前，你需要具备一定的C++编程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值