C++ 实现List

最新推荐文章于 2024-05-06 22:29:10 发布
最新推荐文章于 2024-05-06 22:29:10 发布
阅读量2.3k 收藏 6
点赞数 2
分类专栏： C++ 文章标签： c++ list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XXXTENTAC1ON/article/details/123551949
版权

List

list类设计

template<class _Ty>
class list
{
private:
	struct _Node; //声明结构体
	typedef struct _Node* _Nodeptr; //声明结构体类型指针
	struct _Node
	{
		_Nodeptr _Prev, _Next;
		_Ty _Value;
	};
	struct _Acc;
	struct _Acc
	{
		typedef struct _Node*& _Nodepref; //指针的引用
		typedef _Ty& _Vref; //值的引用
		static _Vref _Value(_Nodeptr _p)
		{
			return (*_p)._Value;
		}
		static _Nodepref _Prev(_Nodeptr _p)
		{
			return (*_p)._Prev;
		}
		static _Nodepref _Next(_Nodeptr _p)
		{
			return (*_p)._Next;
		}
	};

迭代器的使用

迭代器分别有：普通迭代器与常性迭代器

public:
	typedef _Ty value_type;
	typedef _Ty& reference;
	typedef const _Ty& const_reference;
	typedef _Ty* pointer;
	typedef const _Ty* const_pointer;
public:
	class iterator;
	class const_iterator;



	class const_iterator //常性迭代器
	{
	protected:
		_Nodeptr _Ptr;
	public:
		const_iterator(_Nodeptr _P):_Ptr(_P)
		{}
		const_reference operator*()const //常引用进行返回
		{
			return _Acc::_Value(_Ptr);
		}
		const_pointer operator->() 
		{
			return &**this;
		}
		const_iterator& operator++()
		{
			_Ptr = _Acc::_Next(_Ptr);
			return *this;
		}
		const_iterator& operator--()
		{
			_Ptr = _Acc::_Prev(_Ptr);
			return *this;
		}
		const_iterator operator++(int)
		{
			const_iterator tmp = *this;
			++* this;
			return tmp;
		}
		const_iterator operator--(int)
		{
			const_iterator tmp = *this;
			--* this;
			return tmp;
		}
		bool operator==(const const_iterator& _X)const
		{
			return this->_Ptr == _X._Ptr;
		}
		bool operator!=(const const_iterator& _X)const
		{
			return !(*this == _X);
		}
		_Nodeptr _Mynode()const
		{
			return _Ptr;
		}
	
	};

	class iterator:public const_iterator  //is a
	{
	public:
		iterator(_Nodeptr _P) :const iterator(_P) {}
		reference operator*() const
		{
			return _Acc::_Value(_Ptr);
		}
		pointer operator->()const
		{
			return &**this;
		}
		iterator& operator++()
		{
			_Ptr = _Acc::_Next(_Ptr);
			return *this;
		}
		iterator operator++(int)
		{
			iterator tmp = *this;
			++* this;
			return tmp;
		}
		iterator& operator--()
		{
			_Ptr = _Acc::Prev(_Ptr);
			return *this;
		}
		iterator operator--(int)
		{
			iterator tmp = *this;
			--* this;
			return tmp;
		}
		bool operator==(const iterator& _X)const
		{
			return this->_Ptr == _X._Ptr;
		}
		bool operator!=(const iterator & _X)const
		{
			return !(*this == _X);
		}
	};

list类实现

在这里插入图片描述
当我们创建一个链表，此时size大小为0，head指向一个_Node，并且该节点的前驱后继都指向自己

public:
	list()_Head(_Buynode()),_Size(0)
	{}


private:
	_Nodeptr _Head;
	size_t _Size;

	_Nodeptr _Buynode(_Nodeptr _Parg = NULL, _Nodeptr _Narg = NULL) //空间申请
	{
		_Nodeptr _S = (_Nodeptr)malloc(sizeof(_Node));
		_Acc::_Prev(_S) = _Prag == NULL ? _S : _Prag;
		_Acc::_Next(_S) = _Narg == NULL ? _S : _Narg;
		return _S;
	}
	void _Freenode(_Nodeptr P)
	{}	
};

这里会出现一个问题，也就是若构造类为模板类。那么派生类不可以直接使用继承得到的积累数据和方法，需要通过this指针使用，否则会出现“找不到标识符”错误

所以在我们 iterator类 继承 const_iterator类 后，对父类保护成员的使用_Nodeptr _Ptr;，需要加上this指针 this->_Ptr ，或者 const_iterator::_Ptr

通过迭代器进行前插

	iterator insert(iterator _P, const _Ty& val)
	{
		_Nodeptr _S = _P._Mynode();
		_Acc::_Prev(_S) = _Buynode(_Acc::_Prev(_S), _S);//_P的前驱更新为新节点 并且将新结点的前驱后继一同设置完毕
		_S = _Acc::_Prev(_S);//此处将_S指向新结点
		_Acc::_Next(_Acc::_Prev(_S)) = _S; //将新结点的前驱的 _Next 节点设置为新结点
		new(&_Acc::_Value(_S)) _Ty(val);  //_Acc::_Value(_S) = val; 设计类型无法直接赋值
		
		return _P;
	}

上面行代码分别解决了①②③，三个指针的设置，继而只剩下最后一个_Next

之所以使用定位new：若我们list中成员属于设计类型无法直接赋值，需要构建对象进行赋值，在_Value空间地址，构建_Ty类型对象，可以类比为以下

int *p = (int*)malloc(sizeof(int));
new(p) int(12); //在p地址，构建int类型对象

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

尾插与头插方法

void push_front(const _Ty& val)
{
	insert(begin(), val);
}
void push_back(const _Ty& val)
{
	insert(end(), val); 
	//对于双向循环链表，在头结点前插入就是尾插
}

完整代码

list大部分功能进行完善，包括迭代器、插入、删除、交换、列表初始化等等

#pragma once
#include<initializer_list>
namespace zyq
{
template<class T>
void Swap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

template<class _Ty>
class list
{
protected:
	struct _Node; //声明结构体
	typedef struct _Node* _Nodeptr; //声明结构体类型指针
	struct _Node
	{
		_Nodeptr _Prev, _Next;
		_Ty _Value;
	};
	struct _Acc;
	struct _Acc
	{
		typedef struct _Node*& _Nodepref; //指针的引用
		typedef _Ty& _Vref; //值的引用
		static _Vref _Value(_Nodeptr _p)
		{
			return (*_p)._Value;
		}
		static _Nodepref _Prev(_Nodeptr _p)
		{
			return (*_p)._Prev;
		}
		static _Nodepref _Next(_Nodeptr _p)
		{
			return (*_p)._Next;
		}
	};
public:
	typedef _Ty value_type;
	typedef _Ty& reference;
	typedef const _Ty& const_reference;
	typedef _Ty* pointer;
	typedef const _Ty* const_pointer;
public:
	class iterator;
	class const_iterator;
	friend class iterator;
	friend class const_iterator;


	class const_iterator //常性迭代器
	{
	protected:
		_Nodeptr _Ptr;
	public:
		const_iterator(_Nodeptr _P = NULL):_Ptr(_P)
		{}
		const_reference operator*()const //常引用进行返回
		{
			return _Acc::_Value(_Ptr);
		}
		const_pointer operator->() 
		{
			return &**this;
		}
		const_iterator& operator++()
		{
			_Ptr = _Acc::_Next(_Ptr);
			return *this;
		}
		const_iterator& operator--()
		{
			_Ptr = _Acc::_Prev(_Ptr);
			return *this;
		}
		const_iterator operator++(int)
		{
			const_iterator tmp = *this;
			++* this;
			return tmp;
		}
		const_iterator operator--(int)
		{
			const_iterator tmp = *this;
			--* this;
			return tmp;
		}
		bool operator==(const const_iterator& _X)const
		{
			return this->_Ptr == _X._Ptr;
		}
		bool operator!=(const const_iterator& _X)const
		{
			return !(*this == _X);
		}
		_Nodeptr _Mynode()const
		{
			return _Ptr;
		}
	};

	class iterator :public const_iterator  //is a
	{
	public:
		iterator(_Nodeptr _P = NULL) :const_iterator(_P) {}
		reference operator*() const
		{
			return _Acc::_Value(this->_Ptr);
		}
		pointer operator->()const
		{
			return &**this;
		}
		iterator& operator++()
		{
			this->_Ptr = _Acc::_Next(this->_Ptr);
			return *this;
		}
		iterator operator++(int)
		{
			iterator tmp = *this;
			++* this;
			return tmp;
		}
		iterator& operator--()
		{
			this->_Ptr = _Acc::Prev(this->_Ptr);
			return *this;
		}
		iterator operator--(int)
		{
			iterator tmp = *this;
			--* this;
			return tmp;
		}
		bool operator==(const iterator& _X)const
		{
			return this->_Ptr == _X._Ptr;
		}
		bool operator!=(const iterator & _X)const
		{
			return !(*this == _X);
		}
	};
	iterator begin()
	{
		return iterator(_Acc::_Next(_Head));
	}
	iterator end()
	{
		return iterator(_Head);
	}
	const_iterator begin()const 
	{
		return iterator(_Acc::_Next(_Head));
	}
	const_iterator end()const
	{
		return iterator(_Head);
	}

public:
	list(std::initializer_list<_Ty> list):list() //列表方式初始化
	{
		for (auto& x : list)
		{
			push_back(x);
		}
	}
	list():_Head(_Buynode()),_Size(0)
	{}
	list(size_t count,const _Ty&val) :list()  //c11
	{
		insert(begin(), count, val);
	}
	list(const _Ty* _F, const _Ty* _L) :list()
	{
		insert(begin(), _F, _L);
	}//int ar[10]={12,23,34,45,56,67,78,89,90,100};
	list(const list& _X) :_Head(_Buynode()), _Size(0)
	{
		insert(begin(), _X.begin(), _X.end());
	}
	list& operator=(const list _X)
	{
		if (this == &_X) return *this;
		iterator _F1 = begin();
		iterator _L1 = end();
		const_iterator _F2 = _X.begin();
		const_iterator _L2 = _X.end();
		for (; _F1 != _L1 && _F2 != _L2; ++_F1, ++_F2)
		{
			*_F1 = *_F2;
		}//深拷贝，其中一方结束
		erase(_F1, _L1); //被拷贝结束，拷贝者后面节点删除
		insert(_L1, _F2, _L2); //拷贝者结束，将被拷贝后面节点插入拷贝者
	}
	~list()
	{
		clear();
		_Freenode(_Head);
	}
	iterator insert(iterator _P, const _Ty& val)
	{
		_Nodeptr _S = _P._Mynode();
		_Acc::_Prev(_S) = _Buynode(_Acc::_Prev(_S), _S);//_P的前驱更新为新节点 并且将新结点的前驱后继一同设置完毕
		_S = _Acc::_Prev(_S);//此处将_S指向新结点
		_Acc::_Next(_Acc::_Prev(_S)) = _S; //将新结点的前驱的 _Next 节点设置为新结点
		new(&_Acc::_Value(_S)) _Ty(val);   //_Acc::_Value(_S) = val;
		_Size++;
		return _P;
	}
	iterator insert(iterator _P, size_t count, const _Ty& val)
	{
		while (count--)
		{
			insert(_P, val);
		}
		return _P;
	}
	iterator insert(iterator _P, const_iterator _F, const_iterator _L)
	{
		while (_F++ != _L)
		{
			insert(_P, _Acc::_Value(_F));
		}
	}
	void insert(iterator _P, std::initializer_list<_Ty> list)//使用系统的初始化列表
	{
		for (auto& x : list)
		{
			insert(_P, x);
		}
	}//ilist.insert(ilist.begin(),{12,23,34,45,56,67,78,89,90})

	void push_front(const _Ty& val)
	{
		insert(begin(), val);
	}
	void push_back(const _Ty& val)
	{
		insert(end(), val);
	}
	void pop_front()
	{
		erase(begin());
	}
	void pop_back()
	{
		erase(--end());
	}
	void clear()
	{
		erase(begin(), end());
	}
	void remove(const _Ty& val)
	{
		iterator _F = begin(), _L = end();
		while (_F != _L)
		{
			if (*_F == val)
			{
				erase(_F);
				break;
			}
			_F++;
		}
	}
	void remove_all(const _Ty& val)
	{
		iterator _F = begin(), _L = end();
		while (_F != _L)
		{
			if (*_F == val)
			{
				erase(_F++); //删除后_F会变成失效指针，因为该节点已经被删除
			}
			else
			{
				++_F;
			}
		}
	}
	iterator erase(iterator _P)
	{
		_Nodeptr _S = _P++._Mynode();
		_Acc::_Next(_Acc::_Prev(_S)) = _Acc::_Next(_S);
		_Acc::_Prev(_Acc::_Next(_S)) = _Acc::_Prev(_S);
		(&_Acc::_Value(_S))->~Ty(); //释放节点对应数据  进行析构
		_Freenode(_S);
		return _P;
	}
	iterator erase(iterator _F, iterator _L)
	{
		while (_F != _L)
		{
			erase(_F++);
		}
	}
	void Swap(list& _X)
	{
		zyq::Swap(this->_Head, _X._Head);
		zyq::Swap(this->_Size, _X._Size);

	}

private:
	_Nodeptr _Head;
	size_t _Size;

	_Nodeptr _Buynode(_Nodeptr _Parg = NULL, _Nodeptr _Narg = NULL) //空间申请
	{
		_Nodeptr _S = (_Nodeptr)malloc(sizeof(_Node));
		_Acc::_Prev(_S) = _Parg == NULL ? _S : _Parg;
		_Acc::_Next(_S) = _Narg == NULL ? _S : _Narg;
		return _S;
	}

	void _Freenode(_Nodeptr _P)
	{
		free(_P);
	}	
};
}

就地构造

int main()
{
	std::list<Object> alist;
	Object a(10);
	alist.push_back(a);
	
	return 0;
}

以上程序执行，首先构建一个Object对象，随后拷贝构造一个对象在list中
在这里插入图片描述

int main()
{
	std::list<Object> alist;
	alist.push_back(Object(10));
	alist.emplace_back(12); //就地构建 只创建一次
	
	return 0;
}

通过无名对象进行入队，首先会构建一个对象，然后通过移动拷贝构造将此对象的资源进行转移至链表的value值；而就地构造是直接调动构建函数，在结点位置直接构建对象
在这里插入图片描述
在这里插入图片描述

悲伤土豆拌饭
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 自实现的List
04-11
通过c++是实现的List，实现了+和=的操作，就是添加和赋值的意思，也含有其它的基本方法，入push，pop等
【C++】list 的介绍和使用
joy.728的博客
12-17 882
list 是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。list 的底层是带头双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。list 与 forward_list 非常相似：最主要的不同在于forward_list 是单链表，只能朝前迭代，已让其更简单高 效。与其他的序列式容器相比（array，vector，deque），list 通常在任意位置进行插入、移除元素的执行效率更好。
C++ STL之List实现
Juicewyh的博客
09-25 8655
概述     List是STL中常用的容器之一，List将元素按顺序储存到链表中，在快速删除和快速插入方面比vector高出许多。STL中的list是一双向链表，具有指向前一节点和后一节点的指针。那么我们开始写一个属于自己的List吧。 list的节点     list的节点应由指向前一节点的指针，指向后一节点的指针一节储存的元素构成。那么我给出节点的定义 template &lt;ty...
初识C++之list的使用
Masquerena114514的博客
03-10 795
讲解了stl中的list的使用和其中关于迭代器类的实现和注意事项
C++ list的使用
sinat_31608641的博客
08-15 1158
一、简介 list是一种序列式容器。list容器完成的功能实际上和数据结构中的双向链表是极其相似的，list中的数据元素是通过链表指针串连成逻辑意义上的线性表，也就是list也具有链表的主要优点，即：在链表的任一位置进行元素的插入、删除操作都是快速的. 二、list的源码 list的实现大概是这样的：list的每个节点有三个域：前驱元素指针域、数据域和后继元素指针域。前驱元素指针域保存了前驱元素的首地址；数据域则是本节点的数据；后继元素指针域则保存了后继元素的首地址。 list的源码如.
15C++STL之list
LJLThomson的博客
07-07 400
list序列容器 1.简介 list是一种序列式容器，集成了双向链表的优点，所以其实本质也是双向链表。与java中LinkedList基本一致。 2.内部实现机制 list每个元素有三个域：前驱元素指针域、数据域和后继元素指针域。 前驱元素指针域保存了前驱元素的首地址；数据域则是本节点的数据；后继元素指针域则保存了后继元素的首地址。 优点有以下： ​ 1.特别适合插入、删除 ​ 2.特别适合查找首元素和尾部元素，越接近中间，效率越低，时间复杂度为O（n/2) ​ 3.不适合查找中间元素。 3.list构造函
C++STL-list的简易实现
学代码的咸鱼的博客
12-31 534
C++的STL的list简易实现
【C++】list使用
热门推荐
chuxinchangcun的博客
01-05 1万+
age = _age;} int age;//升序 } int main() {//如果想用sort按年龄排序结构体,就需要自定义排序函数 //这里的第三个参数传入的是函数指针,不需要()进行调用 sort(s , s + 3 , cmp);i < 3;i ++) {} }[外链图片转存中…(img-1EiJ8vgQ-1672931727055)]关于迭代器分类单向迭代器：支持++ 如:forword_list 单链表。
从C语言到C++_17(list的模拟实现)list不是原生指针的迭代器
参考书籍：《C语言程序设计》《数据结构》、《C++ Primer》、《Effective C++》、《STL源码剖析》、《现代操作系统》、《图解TCP/IP》、《图解HTTP》、《Linux高性能服务器编程》、《剑指Offer》、《算法导论》
06-07 806
从C语言到C++_17（list的模拟实现）list不是原生指针的迭代器+模板实现const迭代器（开始接触迭代器的精华），list 的反向迭代器放在后面栈和队列期间讲，下一部分：栈和队列：使用，OJ，模拟实现。
C++模拟实现list
03-11
C++模拟实现list
C++实现list链表
12-29
用C++实现链表，对于单链表的运用，添加，删除，在指定的位置添加和删除，实现标准链表的功能。
C++实现的泛型List类分享
09-04
主要介绍了C++实现的泛型List类分享,参考C#的List功能实现,需要的朋友可以参考下
C++实现STL容器之List
04-08
C++实现STL容器之List
C++（引用）
weixin_61218382的博客
05-06 327
给变量其别名数据类型 &别名 = 原名。
【C++第三阶段】list容器&排序
还有很多需要学习，现在还很菜
04-29 733
以下内容仅为当前认识，可能有不足之处，欢迎讨论！
C++关联容器unordered_map无法通过索引来访问元素
book_dw5189的博客
05-06 487
unordered_map 中的元素没有固定的顺序，插入元素的顺序和元素的键值大小没有关系，因此无法通过索引来访问元素。
解密SSL/TLS：密码套件扫描仪的深度解析(C/C++代码实现)
最新发布
chen1415886044的博客
05-06 404
SSL/TLS协议是网络安全中不可或缺的一部分，它们为网络通信提供了传输层的数据安全。 首先，来了解一下SSL和TLS的概念。SSL（安全套接字层）是一种早期的安全协议，它的主要目的是在Web服务器和Web浏览器之间创建加密连接。而TLS（传输层安全性）是SSL的后继者，它在SSL的基础上进行了改进和标准化，目前被广泛使用以确保互联网通信的私密性和数据安全性。 接下来，深入探讨一下SSL/TLS协议的基础构成。SSL/TLS协议主要分为两层，底层是记录协议，负责使用对称密码对消息进行加密。
《21天学通C++》（第十章）实现继承（1）
立志成为炼丹师？
04-28 339
覆盖是一种极端情况，即派生类中的重载方法会隐藏基类中方法的所有重载版本，导致需要调用时无法调用，示例代码如下。解决方法3：在派生类中，把基类中的方法全部重载一次，并在派生类中就调用基类方法。只要派生类中实现了从基类中继承的函数，且返回值和标值相同，就可以覆盖。如果基类包含重载的构造函数，可以使用初始化列表传递参数。，避免不定义的情况下，随机数值产生影响。解决办法1：使用作用域解析符。解决方法2：在派生类中使用。同样使用作用域解析运算符。在构造一个派生类时，使用作用域解析运算符。若想调用基类中的方法。
c++ 查看线程状态
xie__jin__cheng的博客
05-06 133
c++ 查看线程状态
c++ list实现原理
07-15
C++ STL中的list是一个双向链表，它是由一个节点指向前一个节点和后一个节点的指针所组成的一种数据...总之，C++ STL中的list是一种高效的数据结构，它的实现原理基于双向链表和迭代器，可以快速地进行插入和删除操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值