C++系列之list的模拟实现

最新推荐文章于 2024-10-30 21:53:27 发布
最新推荐文章于 2024-10-30 21:53:27 发布
阅读量810 收藏
点赞数
文章标签： c++ list windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjy521_/article/details/134085256
版权

在这里插入图片描述

💗 💗 博客:小怡同学
💗 💗 个人简介:编程小萌新
💗 💗 如果博客对大家有用的话，请点赞关注再收藏 🌞

list的节点类

template
struct list_Node
{
public:
list_Node* _prev;
list_Node* _next;
T _val;
list_Node(const T& val = T())
{
_prev = _next = nullptr;
_val = val;
}
};`

list的迭代器类

//这里写入多个参数的目的是区分const迭代器
//传入不同的模板就会有不同的类
template<class T,class Ref ,class Ptr>
struct list_iterator
{
	public:
		typedef list_Node<T> Node;
		typedef list_iterator<T,Ref,Ptr> self;
		list_iterator(Node* node = nullptr)
		{
			_node = node;
		}
		list_iterator(const self& i)
		{
			_node(i._node);
		}
		//const对象不改变原数据
		T& operator*()
		{
			return _node->_val;
		}
		T* operator->()
		{
			return &_node->val;
		}
		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		self operator++(int)
		{
			self tmp(_node);
			_node = _node->_next;
			return tmp;
		}
		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		self& operator--(int)
		{
			self tmp(_node);
			_node = _node->_prev;
			return tmp;
		}
		bool operator!=(const self& l)
		{
			return _node != l._node;
		}
		bool operator==(const self& l)
		{
			return _node == l._node;
		}

		Node* _node;
	};

构造函数

list(int n, const T& value = T())
{
	_head = new Node();
	_head->_prev = _head;
	_head->_next = _head;
	while (n--)
	{
		push_back(value);
	}
}
template <class Intiterator>
list(Intiterator first, Intiterator last)
{
	//这三行代码的作用是制造一个头结点
	_head = new Node();
	_head->_prev = _head;
	_head->_next = _head;
	
	while (first != last)
	{
		push_back(*first);
		first++;
	}
}
list(const list<T>& l)
{
	_head = new Node();
	_head->_prev = _head;
	_head->_next = _head;
	//这里制造一个list对象，构建与l对象一样的元素，在与*this进行调换。
	list<T> tmp (l.begin(),l.end());
	swap(tmp);
}

析构函数

~list()
{
	clear();//复用clear()函数,如果元素是自定义类型，则一一析构，
	delete _head;
	_head = nullptr;
}

赋值运算符=

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

迭代器的使用


iterator begin()
{
	return iterator(_head->_next);
}
iterator end()
{
	return itertor(_head);
}
//const对象迭代器的使用返回的是const指针(实际上迭代器是一个模板，只是类型不同)
const_iterator begin()const
{
	return const_iterator(_head->_next);
}
const_iterator end()const
{
	return itertor(_head);
}

list的元素大小和判空

size_t size()const//const与非const对象都可调用
{
	return _size;
}
bool empty()const
{
	return _size == 0;
}

访问list的头节点与尾节点

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_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的节点
//这里不会发生迭代器的失效，迭代器没有被改变，返回时返回pos之前的迭代器
iterator insert(iterator pos, const T& val)
{
	Node* newnode = new Node(val);
	Node* node_pos = pos.Node;
	Node* prev = node_pos->_prev;
	Node* next = node_pos->_next;
	prev->_next = next;
	next->_prev = prev;
	return newnode;
}
// 删除pos位置的节点，返回该节点的下一个位置
//这里发生迭代器的失效。指向pos指针变成野指针，返回时需要更新到该节点的下一个位置
iterator erase(iterator pos)
{
	Node* node_pos = pos.Node;
	Node* node_next = pos.Node->_next;
	node_pos->_prev->_next = node_pos->_next;
	node_next->_prev = node_pos->_prev;
	delete node_pos;
	return iterator(node_next);
}
//清除链表，只保留头节点
void clear()
{
	iterator it = begin();
	while (it != end())
	{
		erase(it);
	}
		_head->_prev = _head;
		_head->_next = _head;
}
//交换链表
void swap(const list<T>& L)
{
	Node* tmp = L._head;
	L._head = tmp;
	tmp = _head;
}

#include  <assert.h>
#include <iostream>
using namespace std;
namespace zjy
{
	template<class T>
	struct list_Node
	{
	public:
		list_Node* _prev;
		list_Node* _next;
		T _val;
		list_Node(const T& val = T())
		{
			_prev = _next = nullptr;
			_val = val;
		}
	};
	template<class T,class Ref ,class Ptr>
	struct list_iterator
	{
	public:
		typedef list_Node<T> Node;
		typedef list_iterator<T,Ref,Ptr> self;
		list_iterator(Node* node = nullptr)
		{
			_node = node;
		}
		list_iterator(const self& i)
		{
			_node(i._node);
		}
		T& operator*()
		{
			return _node->_val;
		}
		T* operator->()
		{
			return &_node->val;
		}
		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		self operator++(int)
		{
			self tmp(_node);
			_node = _node->_next;
			return tmp;
		}
		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		self& operator--(int)
		{
			self tmp(_node);
			_node = _node->_prev;
			return tmp;
		}
		bool operator!=(const self& l)
		{
			return _node != l._node;
		}
		bool operator==(const self& l)
		{
			return _node == l._node;
		}

		Node* _node;
	};

	template<class T>
	class list
	{
	public:
		typedef list_Node<T> Node;
		typedef list_iterator<T,T&,T*> iterator;
		typedef list_iterator<T, const T&, const T*> const_iterator;
		list()
		{
			_head = new Node();
			_head->_prev = _head;
			_head->_next = _head;
		}
		
		/*list(int n, const T& value = T())
		{
			_head = new Node();
			_head->_prev = _head;
			_head->_next = _head;
			while (n--)
			{
				Node* newnode = new Node(value);
				Node* tail = _head->_prev;
				tail -> _next = newnode;
				newnode->_prev = _head;

				newnode->_next = _head;
				_head->_prev = newnode;
				tail = newnode;
			}
		}*/
		list(int n, const T& value = T())
		{
			_head = new Node();
			_head->_prev = _head;
			_head->_next = _head;
			while (n--)
			{
				push_back(value);
			}
		}

		/*template <class Intiterator>
		list(Intiterator first, Intiterator last)
		{
			_head = new Node();
			_head->_prev = _head;
			_head->_next = _head;

			Node* begin= first._node;
			Node* end = last._node;
			Node* tail = _head->_prev;
			while (begin != last)
			{
				tail->_next = begin;
				begin->_prev = tail;

				begin->_next = _head;
				_head->_prev = begin;
				
				tail = begin;
				begin++;
			}
		}*/
		template <class Intiterator>
		list(Intiterator first, Intiterator last)
		{
			_head = new Node();
			_head->_prev = _head;
			_head->_next = _head;

		
			while (first != last)
			{
				push_back(*first);
				first++;
			}

		}
		void  swap(const list<T>& L)
		{
			Node* tmp = L._head;
			L._head = tmp;
			tmp = _head;

		}

		list(const list<T>& l)
		{
			_head = new Node();
			_head->_prev = _head;
			_head->_next = _head;

			list<T> tmp (l.begin(),l.end());
			swap(tmp);
		}


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

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


		iterator begin()
		{
			return iterator(_head->_next);
		}
		iterator end()
		{
			return itertor(_head);
		}
		const_iterator begin()const
		{
			return const_iterator(_head->_next);
		}
		const_iterator end()const
		{
			return const_itertor(_head);
		}
		size_t size()const
		{
			return _size;
		}

		bool empty()const
		{
			return _size == 0;
		}
		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_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* newnode = new Node(val);
			Node* node_pos = pos.Node;

			Node* prev = node_pos->_prev;
			Node* next = node_pos->_next;
			
			prev->_next = next;
			next->_prev = prev;


			return newnode;
		}
		// 删除pos位置的节点，返回该节点的下一个位置
		iterator erase(iterator pos)
		{
			Node* node_pos = pos.Node;
			Node* node_next = pos.Node->_next;

			node_pos->_prev->_next = node_pos->_next;
			node_next->_prev = node_pos->_prev;

			delete node_pos;

			return iterator(node_next);
		}

		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				erase(it);
				
			}
			_head->_prev = _head;
			_head->_next = _head;
		}

		void test()
		{
			Node* tmp = _head->_next;
			while (tmp != _head)
			{
				cout << tmp->_val << endl;
				tmp = tmp->_next;
			}
		}
	private:
		Node* _head;
		size_t _size;
	};
}

在这里插入图片描述

小怡同学..
关注
【C++】list类模拟实现
qq_66314292的博客
11-09 2271
list类的模拟实现
C++ 模拟实现list(迭代器)实现代码
08-30
C++ 模拟实现 List（迭代器）实现代码 C++ 模拟实现 List（迭代器）是指使用 C++ 语言来模拟实现 List 数据结构，并提供迭代器来遍历 List 中的元素。在本文中，我们将介绍如何使用 C++ 语言来模拟实现 List（迭代...
【C++】list的模拟实现
小羊的博客
08-14 5008
list详解及模拟实现
【C++】List模拟实现
Renswc的博客
05-31 3155
C++中的list是一种双向链表（doubly linked list）的实现。它是C++标准库中的一种容器，可以存储一系列元素，并且允许在任意位置插入、删除和访问元素。对于双向链表有疑问的可以点击查看数据结构——带头双向循环链表详解对于list大部分和前面学习过的vector类似，关键点在于理解list的迭代器的封装以及const迭代器，还有list实现包括了三个类，它们分别都有类模板，容易绕晕，需要好好理解清楚
【爱上C++】list用法详解、模拟实现
2301_76677973的博客
07-22 4858
文档在这里→官方文档←list是可以在常数范围内（ 时间复杂度为O(1) ）在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代(双向迭代器)。list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
C++——list的使用及其模拟实现
Forward♞的博客
01-28 1751
作为标准模板库中的容器，list同样也是一个类模板如果要定义一个list对象，就需要指定其存储的数据类型T。list
C++ list模拟实现
Han同学
12-25 3127
C++模拟实现list
C++ STL之list的使用及模拟实现
czh1592272237的博客
01-23 2033
本篇文章详细讲解了STL中list的使用及模拟实现，以及反向迭代器类模板的实现。
【C++】list模拟实现
Suk_god的博客
04-23 2525
list容器的模拟实现
【C++】-- STL之list模拟实现
局部变量和全局变量
06-09 1784
list链表的模拟实现，与前面的string和vector相比，略复杂一点： （1）由于链表节点本身就是一个结构体，包含数据域、指针域。 将节点的相关操作放入节点类进行处理，逻辑更清晰 （2）string和vector的元素在空间上是连续分布的，迭代器++就能指向下一个元素，但list的迭代器不行，它的每个元素在空间上都不连续，要访问下一个节点必须找到当前节点的next，因此list的迭代器必须重写............
C++ [STL之list模拟实现]
ARMCSKGT的博客
06-15 6515
list的底层与vector和string不同，实现也有所差别，特别是在迭代器的设计上，本节将为大家介绍list简单实现，并揭开list迭代器的底层！list模拟实现到这里就介绍了，本篇我们简单介绍了一下list的增删功能实现(与链表差别不大)，重点介绍了list的迭代器思想，深入理解list的迭代器可以让我们对类和对象又有进一步的认识，如果我们可以理解list迭代器思想，那么list的其他函数对于我们来说都不成问题！
C++模拟实现list
03-11
C++模拟实现list
《C++显式类型转换：解析多种转换方式的奥秘》
xy520521的博客
10-27 687
当我们从一个存储 Shape 指针的容器中取出指针并希望将其转换为具体的派生类指针以调用特定的绘制方法时，动态_cast可以确保转换的安全性，避免在对象类型不匹配时出现错误。需要注意的是，使用 const_cast修改一个原本被定义为 const 的对象可能会导致未定义的行为，因为这违反了 const 的语义。例如，当我们有一个 const 引用指向一个对象，但在某个特定的函数内部，我们知道这个函数不会修改对象的值，但需要将其传递给一个非 const 版本的函数时，可以使用 const_cast。
linux C++ 动态库dlopen加载示例
编程之道在明明德在亲民在止于至善
10-25 721
linux C++ 动态库dlopen加载示例
linux c-exec系列函数学习
程序猿的成长笔记
10-25 296
这些函数都是以替换的方式，创建一个新的进程替代当前的进程。新的进程与原来的进程号相同，所有的用户空间(代码段、数据段)及部分的内核空间都可以视为是全新的。要注意与fork函数的区别。：可以参考va_start系列的(宏)函数，因此，无论是...，还是vector，还是环境变量的数组，最后一个元素必须是。，相关的错误代码会被设置到errno中。在执行错误的有返回值，且返回值为。
8 深入理解C语言中的变量概念
qq_57484399的博客
10-25 448
在我们日常生活或数学学习中，变量是一个常见的概念。比如在函数中，我们有自变量和因变量。在编程中，变量的作用类似，但它更加具体和实际。变量是程序中可以改变的量，我们可以用一个符号或字母来表示它，比如xy或z。通过今天的学习，我们了解了变量在C语言中的重要性和基本概念。变量是程序中存储和操作数据的关键，它们使得程序能够处理变化的数据。理解变量的本质和如何使用它们，是学习C语言的基础。希望这个解释能够帮助你更好地理解变量，并在你的编程旅程中发挥作用。如果你有任何疑问或需要进一步的解释，请随时提问。
c加加11第一弹~
最新发布
2301_81230745的博客
10-30 717
在C++98中的普通引用与const引用在引用实体上的区别int main()// 普通类型引用只能引用左值，不能引用右值int a = 10;// ra为a的别名// 编译失败，因为10是右值return 0;
C++学习，标准库中的 ＜cassert＞
五味香的专栏
10-25 368
expression是布尔表达式，如果 expression 为 true，则 assert 宏不执行任何操作。如果 expression 为 false，则 assert 宏将输出一条错误信息并终止程序。是 C++ 标准库中的一个头文件，它提供了断言功能，用于在程序运行时检查条件是否为真。如果条件为假，程序将终止执行，并输出一条错误信息。如果断言失败，程序将立即终止，这有助于开发者快速定位问题。// 如果 y 为 0，则以下代码不会执行，因为程序已经在断言失败时终止。
位运算挑战：通过最少位翻转实现 a OR b == c【逐位处理与右移操作】
qq_22841387的博客
10-25 635
通过对ab和c进行逐位比较，我们能够找出最少的位翻转次数，使得a | b == c。该算法的时间复杂度为，空间复杂度为O(1)，非常高效。通过扩展边界条件、复杂度分析和优化方案的讨论，本文不仅详细介绍了基本的位运算方法，也为深入研究和实际应用提供了理论依据。
C++模拟list实现与迭代器详解
C++ 模拟实现list（迭代器）是一种数据结构，用于管理动态大小的双向链表。在C++中，`list`通常由`std::list`库提供，但为了教学或理解底层工作原理，我们可以自定义一个简单的模拟实现。本文档主要关注两个关键部分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值