C++_list简单源码剖析：list模拟实现

最新推荐文章于 2024-10-05 10:33:20 发布
最新推荐文章于 2024-10-05 10:33:20 发布
阅读量1.2k 收藏 11
点赞数 26
文章标签： c++ list 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lvision2/article/details/139360557
版权

文章目录

大家好！本文会用C++模拟一个基本的list类，帮助我们更好的理解list的内置函数的实现与规则。在这里插入图片描述

list是带头双向循环链表，在C语言实现一个链表时，我们通常会实现两个结构体，List 与 ListNode,也就是封装了List的本体与List的节点，在C++模拟实现list也是如此，我们需要实现List与ListNode两个模板。

🚀1. ListNode模板

回忆C语言的链表节点封装，大致其实现为：

struct listnode
{
	listnode* next;
	listnode* prev;
	int val;
};

由此，ListNode的内容是比较简单，我们先行封装ListNode，以模板的形式实现，其成员变量只有一个val与两个指针：指针一个指向前节点，一个指向后节点，val就是存储的数据：

template<class T>
struct ListNode
{
	ListNode<T>* _prev;
	ListNode<T>* _next;
	 
	T _val;
	//构造函数
	ListNode(const T& val = T()) :
		_prev(nullptr),
		_next(nullptr),
		_val(val)
	{

	};
};

备注：

  1. 关于使用struct的原因：在C++中，如果一个类的成员变量全都是需要公开被访问的，我们通常使用struct不用class。我们封装ListNode，实际上是在List类中进行操作的，为了List能更方便的实现ListNode访问上下节点的操作，ListNode的成员必须的public的。
    注: struct默认的所有成员是public，class默认的所有成员是private。
  2. 关于 const T& val = T()在 C++_vector简单源码剖析：vector模拟实现 中⚡️内置类型也有构造函数 这里有说明，其实就是为了当T是内置类型(int , double)的时候，能顺利初始化val。

🚀2. List_iterator模板(重要)

Listiterator就是list的迭代器，提问🎤：在list类的封装中，能不能直接这么定义迭代器？->

template<class T>
class List
{
public:
	typedef ListNode<T> Node;
	typedef Node* iterator;
}

📜答案：不能，为什么🤔？在 C++_vector简单源码剖析：vector模拟实现 中，实现vector的迭代器似乎就是这样实现的，为什么到了list就不行了？
💡解释：在这里插入图片描述
那要如何实现？既然默认的++或者–并不是我们所需要的，那么我们就要自己定义这些行为，这里就需要封装一个Listiterator模板，用一个类来封装ListNode与它的一些行为：

//List的迭代器模板
template<class T, class str, class ptr>
struct Listiterator
{
	typedef ListNode<T> Node;
	typedef Listiterator<T, str, ptr> Self;
	Node* _node;

	//迭代器的构造函数
	Listiterator(Node* pNode = nullptr);
	Listiterator(const Self& l);
	
	// ListNode的一些行为
	//前置++重载，当前节点到下一个节点
	Self operator++();
	//后置++重载，当前节点到下一个节点
	Self operator++(int);
	//前置--重载，当前节点到上一个节点
	Self operator--();
	//后置--重载，当前节点到上一个节点
	Self& operator--(int);
	//解引用重载
	str operator*();
	//->重载
	ptr operator->();
	//!=重载
	bool operator!=(const Self& l);
	//==重载
	bool operator==(const Self& l);
};

📈备注：

  1. 在List模板中会实例化两个版本的迭代器，一个iterator，一个const_iterator, str会传入 T& 与 const T&，ptr会传入T与const T * 。
  2. Listiterator的内容只有一个成员变量ListNode和它的一些行为，这样的过程叫做封装

🌱2.1 List_iterator的构造函数

typedef ListNode<T> Node;
typedef Listiterator<T, str, ptr> Self;
	Node* _node;
//迭代器的构造函数
Listiterator(Node* pNode = nullptr){
	_node = pNode;
}
Listiterator(const Self& l) {
	_node = l._node;
}

📈备注：构造一个迭代器，让其成员ListNode = 传入的ListNode 。

🌱2.2 List_iterator的关于ListNode的行为

	typedef ListNode<T> Node;
	typedef Listiterator<T, str, ptr> Self;
	Node* _node;
//前置++重载，当前节点到下一个节点
Self operator++()
{
	_node = _node->_next;
	return *this;
};
//后置++重载，当前节点到下一个节点
Self operator++(int) {
	Node* tmp = _node;
	_node = _node->_next;
	return tmp;
};
//前置--重载，当前节点到上一个节点
Self operator--()
{
	_node = _node->_prev;
	return *this;
};
//后置--重载，当前节点到上一个节点
Self& operator--(int) {
	Node* tmp = _node;
	_node = _node->_prev;
	return tmp;
};
//解引用重载
str operator*()
{
	return _node->_val;
};
//->重载
ptr operator->()
{
	return &*this;
};
//!=重载
bool operator!=(const Self& l) {
	return l._node !=_node;
};
//==重载
bool operator==(const Self& l) {
	return l._node == _node;
};

📈备注：++让封装的ListNode指向下一个节点，–指向上一个节点， * 解引用得到当前节点的值，->通过this指针使用成员，比较相不相等就是比较是不是同个节点。

🚀3. Reverse_list_iterator模板(拓展)

Reverse_list_iterator就是反向迭代器。

//反向迭代器
template<class T, class str, class ptr>
struct Reverse_list_iterator
{
	typedef ListNode<T> Node;
	typedef Reverse_list_iterator<T, str, ptr> Self;
	Node* _node;

	//构造函数
	Reverse_list_iterator(Node* tmp):
		_node(tmp) {};

	//前置++重载
	Self operator++()
	{
		_node = _node->_prev;
		return *this;
	};
	//后置++重载
	Self operator++(int) {
		Node* tmp = _node;
		_node = _node->_prev;
		return tmp;
	};
	//前置--重载，
	Self operator--()
	{
		_node = _node->_next;
		return *this;
	};
	//后置--重载
	Self& operator--(int) {
		Node* tmp = _node;
		_node = _node->_next;
		return tmp;
	};
	//解引用重载
	str operator*()
	{
		return (_node->_prev)->_val;
	};
	//->重载sh
	ptr operator->()
	{
		return &*this;
	};
	//!=重载
	bool operator!=(const Self& l) {
		return l._node != _node;
	};
	//==重载
	bool operator==(const Self& l) {
		return l._node == _node;
	};

};

📉省流：与正常迭代器不同的地方就是 ++ ， – ，和解引用 * ， * 解引用获得的是上一个节点的值。

🚀4. List模板(核心)

List模板有很多的成员函数，我们先大致浏览一下它的成员：

	template<class T>
	class List
	{
	public:
		typedef ListNode<T> Node;
		//迭代器命名
		typedef Listiterator<T, T&, T*> iterator;
		typedef Listiterator<T, const T&, const T*> const_iterator;
		typedef Reverse_list_iterator<T, T&, T*> reverse_list_iterator;
		typedef Reverse_list_iterator<T, const  T&, const  T*> const_reverse_list_iterator;
		//1.  List的构造
		//默认构造
		List();
		//传值构造
		List(int n, const T& value = T());
		//迭代器构造
		template <class Iterator>
		List(Iterator first, Iterator last);
		//拷贝构造
		List(const List<T>& l);
		//赋值重载
		List<T>& operator=(List<T> l);
		//析构函数
		~List();


		//2. 迭代器
		iterator begin() ;
		iterator end();
		const_iterator begin() const;
		const_iterator end() const;
		reverse_list_iterator rbegin();
		reverse_list_iterator rend();
		const_reverse_list_iterator rbegin() const;
		const_reverse_list_iterator rend() const;

		//3. 内容相关
		size_t size()const;
		bool empty()const;

		//4. 获取头尾元素
		T& front();
		const T& front()const;
		T& back();
		const T& back()const;

		//5. 内存修改
		void push_back(const T& val);
		void pop_back();
		void push_front(const T& val);
		void pop_front();

		// 在pos位置前插入值为val的节点
		//不存在迭代器失效
		iterator insert(iterator pos, const T& val);

		// 删除pos位置的节点，返回该节点的下一个位置
		//存在迭代器失效
		iterator erase(iterator pos);

		void clear();
		void swap(List<T>& l);
	private: 
		Node* _pHead;
		void createhead()
		{
			_pHead = new Node;
			_pHead->_prev = _pHead;
			_pHead->_next = _pHead;
		}
	};
}

🌱4.1 List构造函数

//创造head节点
void createhead()
{
		_pHead = new Node;
		_pHead->_prev = _pHead;
		_pHead->_next = _pHead;
}
//默认构造
List()
{
	createhead();
}
//传值构造
List(int n, const T& value = T())
{
	createhead();
	for (int i = 0; i < n; ++i)
	push_back(value);
}
//迭代器构造
template <class Iterator>
List(Iterator first, Iterator last)
{
	createhead();
	auto start = first;
	while (start != last)
	{
		push_back(*start);
		start++;
	};
};
//拷贝构造
List(const List<T>& l)
{
	createhead();
	for (auto e : l)
	{
		push_back(e);
	}
};

//赋值重载
List<T>& operator=(List<T> l)
{
	swap(_pHead, l._pHead);
	return *this;
}
//析构函数
~List()
{
	clear();
	delete _pHead;
}

📈备注：

  1. 默认构造支持创建空List。
  2. 传值构造支持创建长度为n，值为value的List。
  3. 迭代器构造支持通过传入迭代器进行初始化的List.
  4. 拷贝构造和赋值重载支持传入一个List进行初始化。
  5. 析构函数要先clear，这个clear就是清除所有节点的函数，后面会实现。

🌱4.2 List迭代器

一般迭代器：

typedef ListNode<T> Node;
typedef Listiterator<T, T&, T*> iterator;
typedef Listiterator<T, const T&, const T*> const_iterator;

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

📈备注：begin()返回头节点，end()返回尾节点的下一个节点（就是head节点）

反向迭代器：

typedef ListNode<T> Node;
typedef Reverse_list_iterator<T, T&, T*> reverse_list_iterator;
typedef Reverse_list_iterator<T, const  T&, const  T*> const_reverse_list_iterator;

reverse_list_iterator rbegin(){
	return reverse_list_iterator(_pHead);
};
reverse_list_iterator rend()
{
	return reverse_list_iterator(_pHead->_next);
};
const_reverse_list_iterator rbegin() const
{
	return const_reverse_list_iterator(_pHead);
};
const_reverse_list_iterator rend() const
{
	return const_reverse_list_iterator(_pHead->_next);
};

📈备注：begin()返回头节点前一个节点（就是head节点），end()返回尾节点

🌱4.3 List内容相关函数

size_t size()const
{
	size_t size = 0;
	auto it = begin();
	while (it != end())
	{
		size++;
		it++;
	}
	return size;
}
bool empty()const
{
	return size() == 0;
}

📈备注：size与empty函数慎用，时间复杂度为O(n)。

🌱4.4 List获取头尾元素

T& front()
{
	return (_pHead->_next)->_val;
}
const T& front()const
{
	return (_pHead->_next)->_val;
}
T& back()
{
	return (_pHead->_prev)->_val;
}
const T& back()const
{
	return (_pHead->_prev)->_val;
}

📈备注：注意要多实现一个const版本的。

🌱4.5 List内存修改

//5. 内存修改
void push_back(const T& val) {
	insert(end(), val);
};
void pop_back() {
	erase(--end());
};
void push_front(const T& val) {
	insert(begin(), val);
};
void pop_front() {
	erase(begin());
};

// 在pos位置前插入值为val的节点
//不存在迭代器失效
iterator insert(iterator pos, const T& val) {
	Node* tmp = new Node(val);
	Node* cur = pos._node;
	Node* prev = cur->_prev;

	tmp->_next = cur;
	tmp->_prev = prev;

	cur->_prev = tmp;
	prev->_next = tmp;

	return  iterator(tmp);
};

// 删除pos位置的节点，返回该节点的下一个位置
//存在迭代器失效
iterator erase(iterator pos)
{
	Node* Prew = pos._node->_prev;
	Node* Next = pos._node->_next;
	delete pos._node;
	Prew->_next = Next;
	Next->_prev = Prew;
	return Next;
};

void clear() { 
	iterator start = begin();
	while (start != end())
	{
		start = erase(start);
	}
	_pHead->_next = _pHead;
	_pHead->_prev = _pHead;
}
void swap(List<T>& l)
{
	Node tmp = _pHead;
	_pHead = l._pHead;
	l._pHead = tmp;
}

📈备注：insert传入的迭代器不会失效，但是erase传入的迭代器会失效，erase返回删除节点的下一个节点的有效迭代器。其他是内存修改函数都是通过复用insert与erase实现的。

由此全部完成，附上总代码图：

#pragma once
namespace bit
{
	//ListNode节点
	template<class T>
	struct ListNode
	{
		ListNode<T>* _prev;
		ListNode<T>* _next;
		 
		T _val;

		ListNode(const T& val = T()) :
			_prev(nullptr),
			_next(nullptr),
			_val(val)
		{

		};
	};

	

	
	//List的迭代器模板
	template<class T, class str, class ptr>
	struct Listiterator
	{
		typedef ListNode<T> Node;
		typedef Listiterator<T, str, ptr> Self;
		Node* _node;

		//迭代器的构造函数
		Listiterator(Node* pNode = nullptr){
			_node = pNode;
		}
		Listiterator(const Self& l) {
			_node = l._node;
		}

		//前置++重载，当前节点到下一个节点
		Self operator++()
		{
			_node = _node->_next;
			return *this;
		};
		//后置++重载，当前节点到下一个节点
		Self operator++(int) {
			Node* tmp = _node;
			_node = _node->_next;
			return tmp;
		};
		//前置--重载，当前节点到上一个节点
		Self operator--()
		{
			_node = _node->_prev;
			return *this;
		};
		//后置--重载，当前节点到上一个节点
		Self& operator--(int) {
			Node* tmp = _node;
			_node = _node->_prev;
			return tmp;
		};
		//解引用重载
		str operator*()
		{
			return _node->_val;
		};
		//->重载
		ptr operator->()
		{
			return &*this;
		};
		//!=重载
		bool operator!=(const Self& l) {
			return l._node !=_node;
		};
		//==重载
		bool operator==(const Self& l) {
			return l._node == _node;
		};
	};

	//反向迭代器
	template<class T, class str, class ptr>
	struct Reverse_list_iterator
	{
		typedef ListNode<T> Node;
		typedef Reverse_list_iterator<T, str, ptr> Self;
		Node* _node;

		//构造函数
		Reverse_list_iterator(Node* tmp):
			_node(tmp) {};

		//前置++重载
		Self operator++()
		{
			_node = _node->_prev;
			return *this;
		};
		//后置++重载
		Self operator++(int) {
			Node* tmp = _node;
			_node = _node->_prev;
			return tmp;
		};
		//前置--重载，
		Self operator--()
		{
			_node = _node->_next;
			return *this;
		};
		//后置--重载
		Self& operator--(int) {
			Node* tmp = _node;
			_node = _node->_next;
			return tmp;
		};
		//解引用重载
		str operator*()
		{
			return (_node->_prev)->_val;
		};
		//->重载
		ptr operator->()
		{
			return &*this;
		};
		//!=重载
		bool operator!=(const Self& l) {
			return l._node != _node;
		};
		//==重载
		bool operator==(const Self& l) {
			return l._node == _node;
		};

	};

	//list模板
	template<class T>
	class List
	{
	public:
		typedef ListNode<T> Node;
		//迭代器命名
		typedef Listiterator<T, T&, T*> iterator;
		typedef Listiterator<T, const T&, const T*> const_iterator;
		typedef Reverse_list_iterator<T, T&, T*> reverse_list_iterator;
		typedef Reverse_list_iterator<T, const  T&, const  T*> const_reverse_list_iterator;
		//1.  List的构造
		//默认构造
		List()
		{
			createhead();
		}
		//传值构造
		List(int n, const T& value = T())
		{
			createhead();
			for (int i = 0; i < n; ++i)
			push_back(value);
		}
		//迭代器构造
		template <class Iterator>
		List(Iterator first, Iterator last)
		{
			createhead();
			auto start = first;
			while (start != last)
			{
				push_back(*start);
				start++;
			};
		};
		//拷贝构造
		List(const List<T>& l)
		{
			createhead();
			for (auto e : l)
			{
				push_back(e);
			}
		};

		//赋值重载
		List<T>& operator=(List<T> l)
		{
			swap(_pHead, l._pHead);
			return *this;
		}
		//析构函数
		~List()
		{
			clear();
			delete _pHead;
		}


		//2. 迭代器
		iterator begin() {
			return iterator(_pHead->_next);
		};
		iterator end()
		{
			return iterator(_pHead);
		};
		const_iterator begin() const
		{
			return const_iterator(_pHead->_next);
		};
		const_iterator end() const
		{
			return const_iterator(_pHead);
		};

		reverse_list_iterator rbegin(){
			return reverse_list_iterator(_pHead);
		};
		reverse_list_iterator rend()
		{
			return reverse_list_iterator(_pHead->_next);
		};
		const_reverse_list_iterator rbegin() const
		{
			return const_reverse_list_iterator(_pHead);
		};
		const_reverse_list_iterator rend() const
		{
			return const_reverse_list_iterator(_pHead->_next);
		};

		//3. 内容相关
		size_t size()const
		{
			size_t size = 0;
			auto it = begin();
			while (it != end())
			{
				size++;
				it++;
			}
			return size;
		}
		bool empty()const
		{
			return size() == 0;
		}


		//4. 获取头尾元素
		T& front()
		{
			return (_pHead->_next)->_val;
		}
		const T& front()const
		{
			return (_pHead->_next)->_val;
		}
		T& back()
		{
			return (_pHead->_prev)->_val;
		}
		const T& back()const
		{
			return (_pHead->_prev)->_val;
		}

		//5. 内存修改
		void push_back(const T& val) {
			insert(end(), val);
		};
		void pop_back() {
			erase(--end());
		};
		void push_front(const T& val) {
			insert(begin(), val);
		};
		void pop_front() {
			erase(begin());
		};

		// 在pos位置前插入值为val的节点
		//不存在迭代器失效
		iterator insert(iterator pos, const T& val) {
			Node* tmp = new Node(val);
			Node* cur = pos._node;
			Node* prev = cur->_prev;

			tmp->_next = cur;
			tmp->_prev = prev;

			cur->_prev = tmp;
			prev->_next = tmp;

			return  iterator(tmp);
		};

		// 删除pos位置的节点，返回该节点的下一个位置
		//存在迭代器失效
		iterator erase(iterator pos)
		{
			Node* Prew = pos._node->_prev;
			Node* Next = pos._node->_next;
			delete pos._node;
			Prew->_next = Next;
			Next->_prev = Prew;
			return Next;
		};

		void clear() { 
			iterator start = begin();
			while (start != end())
			{
				start = erase(start);
			}
			_pHead->_next = _pHead;
			_pHead->_prev = _pHead;
		}
		void swap(List<T>& l)
		{
			Node tmp = _pHead;
			_pHead = l._pHead;
			l._pHead = tmp;
		}
	private: 
		Node* _pHead;
		void createhead()
		{
			_pHead = new Node;
			_pHead->_prev = _pHead;
			_pHead->_next = _pHead;
		}
	};
}

本文就到这里，感谢你看到这里❤️❤️！
我知道一些人看文章喜欢静静看，不评论🤔，但是他会点赞😍，这样的人，帅气低调有内涵😎，美丽大方很优雅😊，明人不说暗话，要你手上的一个点赞😘！

Length-vision
关注
C++内存分配详解五：std::alloc源码剖析
qq_34269632的博客
04-13 1414
标准容器分配器源码剖析
【C++】list的介绍及模拟实现
East-sunrise的博客
01-03 700
STL库的list也不过如此
list链表c++源代码
08-25
使用C++ 代码编写的一个链表，类似于C++ STL中的容器list。可以放入任何类型的数据，通过迭代器访问链表。涉及到的技术很多。
C++-list源码初探-个人理解&编写思路
李木子的博客
04-18 503
文章目录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
最新发布
2301_79998744的博客
10-05 2123
list的模拟实现
C++ list 源码学习
weixin_30919571的博客
07-26 195
一. list 实例 #include<list> //调用系统的list,双向循环链表结构 using namespace std; int main(void) { list<int> mylist; for(int i = 1; i <= 10; i++) { ...
【C++从0到王者】第十五站：list源码分析及手把手教你写一个list
青色_忘川的博客
08-02 856
list源码分析以及手把手教你写一个简单的list
C++ list最详细教程1 （包含程序源码）
勤天下而拥家
01-02 1028
/* list test demo time:2017.1.2在任何位置插入删除都是常数时间，不支持随机存取。除了具有所有顺序容器都有的成员函数以外，还支持8个成员函数： push_front: 在前面插入 pop_front: 删除前面的元素 sort: 排序( list 不支持STL 的算法sort) remove: 删除和指定值相等的所有元素 unique: 删除所有和前一个元素相同的元
【C++】STL容器之list
DanteKing的博客
02-08 1303
stl之list的详解和模拟实现
C++模板编程深度解析：std::queue源码剖析与性能优化秘籍
[C++模板编程深度解析：std::queue源码剖析与性能优化秘籍](https://www.simplilearn.com/ice9/free_resources_article_thumb/C%2B%2B_code2-Queue_Implementation_Using_Array.png) # 1. C++模板编程基础 在现代...
【C++ STL】list 容器（介绍、使用、@迭代器失效、@迭代器的分类与实现方式、模拟实现、list 和 vector 的对比）
codewinter的博客
05-25 1215
文章目录一、STL - list 的介绍二、list 的使用2.1 常见构造2.2 迭代器及其遍历操作2.3 容量操作2.4 访问操作2.5 修改操作① 迭代器失效（⭐）② 成员 / 非成员 swap 函数2.6 容器操作（了解，用的很少）三、容器迭代器（重要）3.1 容器迭代器的分类（⭐重要）3.2 迭代器的实现方式分析（⭐重要）四、stl_list 源码剖析4.1 list 的底层结构五、list 的模拟实现5.1 list 的节点结构5.2 list 的迭代器（⭐重要）① 迭代器的结构② 一些思考（⭐
c++list类实现
11-23
1）代码注释很详细的，非常适合学习STL的。 2）数据结构里面两种非常重要的存储结构，线性结构中的连续存储结构（代表vector数组）和非连续存储结构（代表list链表），他们两者被广泛的应用在各个领域，是最基本最基础的两种存储结构； 3）之前的友元类只是停留在理论层面，真正实现还是头一次；友元类非常像java中的内部类
线性表list_array的源代码(c语言)
12-10
#ifndef __LIST_H__ #define __LIST_H__ struct list; struct list *list_init(); void list_free(struct list *list); int list_isempty(struct list *list); void list_clear(struct list *list); int list_count(struct list *list); int list_get(struct list *list, int index); int list_remove(struct list *list, int index); void list_set(struct list *list, int index, int value); void list_add(struct list *list, int index, int value); int list_lookup(struct list *list, int value); int list_indexof(struct list *list, int value); #endif /* __LIST_H__ */
C++——list的实现以及源码
zgwnb666的博客
05-26 771
C++——list的实现以及源码
【c++之容器】——list的源码模拟实现
sjp11的博客
08-15 826
目录 1.list的概述 2.list的节点 3.list的迭代器 4.list的数据结构 a.插入节点 b.删除节点 1.list的概述 list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指 针指向其前一个元素和后一个元素。它的优点是每次插入或删除一个元素，就配置或释放一个元素的空间。所以对于空间的管理比较精准，一点也不浪费。而且对于任何的元素插入或删除，它的时间复杂度为O（1），非常高效。 2.list的节点 list本身与list.
C++之ListNode
weixin_38168322的博客
05-09 4373
单链表，弄清楚可stl中list的区别 ListNode的结构 struct ListNode { int val; //当前结点的值 ListNode *next; //指向下一个结点的指针 ListNode(int x) : val(x), next(NULL) {} //初始化当前结点值为x,指针为空 }; ...
C++语法——超详细模拟实现list源代码
weixin_61857742的博客
10-18 1901
这篇小编将以SGI版的list为例进行模拟实现。这里小编做了一张图，它足以表明list的大致框架：对于节点node而言，我们可以按照c语言中的双向链表节点结构进行创建。首先node设为一种类由于list属于泛型编程，我们不知道链表数据类型，因此使用template将node变成泛型类。内部参数分别是node* next，node* prev，T value。通过代码我们可以发现，在结构上list_node与c语言的结构体链表节点基本无异。但是C++特性赋予了链表节点泛型编程的强大功能。当
C++ STL-List源码分析
HanMeng的博客
04-25 2587
文章目录： 对源码中的私有成员数据进行刨析，根据缺什么补什么，对私有成员的数据类型进行声明 源码中私有成员如下： 刨析后如下： #include<iostream> using namespace std; namespace code { template <class _Ty> class list { public: //类型的萃取 typedef size_t size_type;//大小的类型 typedef _Ty value_type
c++ list 容器源码架构
w593942008的博客
04-18 434
using _Mybase = _List_buy<_Ty, _Alloc>; using iterator = typename _Mybase::iterator; 迭代器 迭代器类 ：_List_unchecked_const_iterator 、 _List_unchecked_iterator 、 List_const_iterator、class _List_iter...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值