1. Toy模板网首页
  2. > Toy博客

C++初阶（十四）list

8月前 作者：北尘_ 分类：Toy博客 阅读(25) 违法举报

这篇具有很好参考价值的文章主要介绍了C++初阶（十四）list。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

C++初阶（十四）list,C++,c++,list,开发语言

📘北尘_：个人主页

🌎个人专栏:《Linux操作系统》《经典算法试题 》《C++》 《数据结构与算法》
☀️走在路上，不忘来时的初心

一、 list的介绍

  1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
  2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
  3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
  4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
  5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)

C++初阶（十四）list,C++,c++,list,开发语言

二、list的模拟实现

1、list的节点

template<class T>
	struct list_node
	{
		T _data;
		list_node<T>* _prev;
		list_node<T>* _next;

		list_node(const T& x = T())
			:_data(x)
			, _next(nullptr)
			, _prev(nullptr)
		{}
	};

2、list 的迭代器

template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref, Ptr> self;
		Node* _node;

		__list_iterator(Node* node)
			:_node(node)
		{}

		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

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

		self operator++(int)
		{
			self tmp(*this);
			_node = _node->_next;

			return tmp;
		}

		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;

			return tmp;
		}

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

		Ptr operator->()
		{
			return &_node->_data;
		}

		bool operator!=(const self& s)
		{
			return _node != s._node;
		}

		bool operator==(const self& s)
		{
			return _node == s._node;
		}
	};

3、list

template<class T>
	class list
	{
		typedef list_node<T> Node;
	public:
		typedef __list_iterator<T, T&, T*> iterator;
		typedef __list_iterator<T, const T&, const T*> const_iterator;
		
		iterator begin()
		{
			return _head->_next;
		}
		iterator end()
		{
			return _head;
		}
		const_iterator begin() const
		{
			return _head->_next;
		}

		const_iterator end() const
		{
			return _head;
		}
		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}
		list()
		{
			empty_init();
		}
		list(list<T>& lt)
		{
			empty_init();
			for (auto e : lt)
			{
				push_back(e);
			}
		}
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}
		void swap(list<T> lt)
		{
			std::swap(_size, lt._size);

			std::swap(_head, lt._head);
		}
		
		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(x);

			Node* prev = cur->_prev;

			prev->_next = newnode;
			newnode->_prev = prev;

			newnode->_next = cur;
			cur->_prev = newnode;
			++_size;

			return iterator(newnode);
		}
		iterator erase(iterator pos)
		{
			Node* cur = pos._node;

			Node* prev = cur->_prev;
			Node* next = cur->_next;
			delete cur;
			prev->_next = next;
			next->_prev = prev;
			--_size;
		}
		size_t size()
		{
			return _size;
		}
		void clear()
		{
			iterator it = begin();
			while (it != end)
			{
				it = erase(it);
			}
		}
		void push_back(const T& x)
		{
			insert(end(), x);
		}
		void push_front(const T& x)
		{
			insert(begin(), x);
		}
		void push_back()
		{
			erase(end());
		}
		void pop_back()
		{

			erase(begin());
		}
		

		
	private:
		Node* _head;
		size_t _size;


	};

4、打印

template<typename Container>
	void print_container(const Container& con)
	{
		typename Container::const_iterator it = con.begin();
		while (it != con.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}
	void test_list()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		lt.push_back(5);
	
		print_container(lt);

		list<string> lt1;
		lt1.push_back("1111111111111");
		lt1.push_back("1111111111111");
		lt1.push_back("1111111111111");
		lt1.push_back("1111111111111");
		lt1.push_back("1111111111111");
		
		print_container(lt1);

		vector<string> v;
		v.push_back("222222222222222222222");
		v.push_back("222222222222222222222");
		v.push_back("222222222222222222222");
		v.push_back("222222222222222222222");
		
		print_container(v);
		
	}
}
int main()
{
	bit::test_list();
	return 0;
}

5、完整代码

#include<iostream>
#include<string>
#include<vector>
using namespace std;
namespace bit
{
	template<class T>
	struct list_node
	{
		T _data;
		list_node<T>* _prev;
		list_node<T>* _next;

		list_node(const T& x = T())
			:_data(x)
			, _next(nullptr)
			, _prev(nullptr)
		{}
	};
	template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref, Ptr> self;
		Node* _node;

		__list_iterator(Node* node)
			:_node(node)
		{}

		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

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

		self operator++(int)
		{
			self tmp(*this);
			_node = _node->_next;

			return tmp;
		}

		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;

			return tmp;
		}

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

		Ptr operator->()
		{
			return &_node->_data;
		}

		bool operator!=(const self& s)
		{
			return _node != s._node;
		}

		bool operator==(const self& s)
		{
			return _node == s._node;
		}
	};
	template<class T>
	class list
	{
		typedef list_node<T> Node;
	public:
		typedef __list_iterator<T, T&, T*> iterator;
		typedef __list_iterator<T, const T&, const T*> const_iterator;
		
		iterator begin()
		{
			return _head->_next;
		}
		iterator end()
		{
			return _head;
		}
		const_iterator begin() const
		{
			return _head->_next;
		}

		const_iterator end() const
		{
			return _head;
		}
		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}
		list()
		{
			empty_init();
		}
		list(list<T>& lt)
		{
			empty_init();
			for (auto e : lt)
			{
				push_back(e);
			}
		}
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}
		void swap(list<T> lt)
		{
			std::swap(_size, lt._size);

			std::swap(_head, lt._head);
		}
		
		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* newnode = new Node(x);

			Node* prev = cur->_prev;

			prev->_next = newnode;
			newnode->_prev = prev;

			newnode->_next = cur;
			cur->_prev = newnode;
			++_size;

			return iterator(newnode);
		}
		iterator erase(iterator pos)
		{
			Node* cur = pos._node;

			Node* prev = cur->_prev;
			Node* next = cur->_next;
			delete cur;
			prev->_next = next;
			next->_prev = prev;
			--_size;
		}
		size_t size()
		{
			return _size;
		}
		void clear()
		{
			iterator it = begin();
			while (it != end)
			{
				it = erase(it);
			}
		}
		void push_back(const T& x)
		{
			insert(end(), x);
		}
		void push_front(const T& x)
		{
			insert(begin(), x);
		}
		void push_back()
		{
			erase(end());
		}
		void pop_back()
		{

			erase(begin());
		}
		

		
	private:
		Node* _head;
		size_t _size;


	};

	template<typename Container>
	void print_container(const Container& con)
	{
		typename Container::const_iterator it = con.begin();
		while (it != con.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}
	
	void test_list()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		lt.push_back(5);
	
		print_container(lt);

		list<string> lt1;
		lt1.push_back("1111111111111");
		lt1.push_back("1111111111111");
		lt1.push_back("1111111111111");
		lt1.push_back("1111111111111");
		lt1.push_back("1111111111111");
		
		print_container(lt1);

		vector<string> v;
		v.push_back("222222222222222222222");
		v.push_back("222222222222222222222");
		v.push_back("222222222222222222222");
		v.push_back("222222222222222222222");
		
		print_container(v);
		
	}
}
int main()
{
	bit::test_list();
	return 0;
}

C++初阶（十四）list,C++,c++,list,开发语言文章来源地址https://www.toymoban.com/news/detail-757771.html

到了这里，关于C++初阶（十四）list的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【C++初阶】第十篇：list模拟实现

    【C++初阶】第十篇：list模拟实现

    我们经常说list在底层实现时就是一个链表，更准确来说，list实际上是一个带头双向循环链表。 因此，我们若要实现list，则首先需要实现一个结点类。而一个结点需要存储的信息有：数据、前一个结点的地址、后一个结点的地址，于是该结点类的成员变量也就出来了（数据、

    2023年04月17日
    浏览(30)
  • 【C++初阶】list的模拟实现 附源码

    【C++初阶】list的模拟实现 附源码

    list底层是一个 双向带头循环链表 ，这个我们以前用C语言模拟实现过，-双向带头循环链表 下面是list的文档介绍： list文档介绍 我们会根据 list 的文档来模拟实现 list 的增删查改及其它接口。   既然是用C++模拟实现的，那么一定要 封装在类里 。 为了适合各种类型的数据，

    2024年02月17日
    浏览(32)
  • C++初阶—list深度解剖及模拟实现

    C++初阶—list深度解剖及模拟实现

      目录 ➡️0. 前言 😊1.简易框架实现 🐔1. list和__list_node分析实现 🐔2. 无参构造 😊2.迭代器实现 🐔1. list普通迭代器面临问题及解决方案 🐔2. __list_nodeiteratorlist三类分析 🐔3. list中const迭代器面临问题及解决方案 🐔4. list中模板参数为自定义类型迭代器优化 🐔5. list迭代

    2024年02月09日
    浏览(29)
  • 【C++初阶】11. list的使用及模拟实现

    【C++初阶】11. list的使用及模拟实现

    list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。 list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。 list与forward_list非常相似：最主要的不同在

    2024年02月12日
    浏览(31)
  • 【C++初阶】STL详解（五）List的介绍与使用

    【C++初阶】STL详解（五）List的介绍与使用

    本专栏内容为：C++学习专栏，分为初阶和进阶两部分。 通过本专栏的深入学习，你可以了解并掌握C++。 💓博主csdn个人主页：小小unicorn ⏩专栏分类：C++ 🚚代码仓库：小小unicorn的代码仓库🚚 🌹🌹🌹关注我带你学习编程知识 1.list是一种可以在常数范围内在任意位置进行插

    2024年02月04日
    浏览(35)

  • 【C++初阶9-list实现】封装——我主沉浮，何不能至？

    翻阅文档即可。 带头双向循环链表。 *数据结构初阶已经实现过，这里只是变成类和对象的版本 list的实现，价值最大的不是这里，而是迭代器…… 封装，我主沉浮，何不能至？ 封装给了我们很灵活的操作空间。为什么这么说？ 迭代器是一种类的内嵌类型，具有指针行为，

    2023年04月27日
    浏览(28)
  • C++初阶之一篇文章教会你list（模拟实现）

    C++初阶之一篇文章教会你list（模拟实现）

    成员类型表 这个表中列出了C++标准库中list容器的一些成员类型定义。这些类型定义是为了使list能够与C++标准库的其他组件协同工作，并提供一些通用的标准接口。每个成员类型的用处： value_type : 这个成员类型代表list容器中存储的数据类型，即模板参数T的类型。 allocator_

    2024年02月12日
    浏览(26)
  • 【C++从0到王者】第十四站：list基本使用及其介绍

    【C++从0到王者】第十四站：list基本使用及其介绍

    如下所示，是库里面对list的基本介绍 链表是序列容器，允许在序列内的任何位置进行常量时间的插入和擦除操作，以及两个方向的迭代。 链表容器被实现为双链表;双链表可以将它们包含的每个元素存储在不同且不相关的存储位置。排序是通过与前面元素的链接和后面元素的

    2024年02月14日
    浏览(37)
  • C++初阶之一篇文章教会你list（理解和使用）

    C++初阶之一篇文章教会你list（理解和使用）

    在C++标准库中， std::list 是一个双向链表容器，用于存储一系列元素。与 std::vector 和 std::deque 等容器不同， std::list 使用链表的数据结构来组织元素，因此在某些操作上具有独特的优势和性能特点。以下是关于 std::list 的详细介绍： 双向链表结构： std::list 内部使用双向链表来

    2024年02月13日
    浏览(36)
  • 鸿蒙开发系列教程（二十四）--List 列表操作（3）

    鸿蒙开发系列教程（二十四）--List 列表操作（3）

    定义列表项数据结构和初始化列表数据，构建列表整体布局和列表项。 提供新增列表项入口，即给新增按钮添加点击事件。 响应用户确定新增事件，更新列表数据。 列表的删除功能一般进入编辑模式后才可使用，所以需要提供编辑模式的入口。 需要响应用户的选择交互，记

    2024年02月21日
    浏览(33)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包