c++学习（list）[9]

最新推荐文章于 2024-05-12 20:36:20 发布
最新推荐文章于 2024-05-12 20:36:20 发布
阅读量211 收藏
点赞数
分类专栏： C++ 文章标签： c++ 学习 list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53022035/article/details/131611720
版权

list的使用

在这里插入图片描述
头文件：

 #inliude<list>

C++标准库（STL）中的std::list是一个双向链表容器，它提供了一些有用的操作和功能。与std::vector相比，std::list具有以下特点：

  1. 链表结构：std::list使用链表结构实现，每个元素都包含指向前一个和后一个元素的指针，因此在插入和删除元素时，不会涉及内存的重新分配和移动，相对于std::vector，插入和删除操作的时间复杂度为O(1)。

  2. 无连续内存：由于std::list使用链表实现，它的元素在内存中是不连续存储的。这意味着std::list不支持随机访问，不能像std::vector那样使用索引访问元素，只能通过迭代器进行遍历。

  3. 动态大小：std::list的大小可以动态增长和收缩，不需要预先指定容器的大小。

  4. 插入和删除效率高：由于链表结构的特性，std::list在任意位置插入和删除元素的效率都很高，不会引起其他元素的移动。

  5. 不支持快速随机访问：由于没有连续的内存存储，std::list不支持像std::vector那样的快速随机访问。如果需要通过索引访问元素，应该使用std::vector。

std::list提供了一系列成员函数和算法，可以方便地对链表进行操作，例如push_back()、push_front()、pop_back()、pop_front()、insert()、erase()等。此外，std::list还提供了size()、empty()、front()、back()等成员函数来获取链表的大小和访问元素。

需要注意的是，由于std::list的元素在内存中不是连续存储的，因此在访问元素时，性能可能相对较低。如果需要频繁的随机访问和修改元素，std::vector可能是更好的选择。而std::list在需要频繁插入和删除元素的场景下，具有更好的性能。

listd的尾插和遍历举例

#include<iostream>
#include<list>
using namespace std;

void test_list1()
{
	list<int> lt;
	//插入数据（尾插）
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	//遍历：迭代器
	list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	it = lt.begin();        //迭代器修改值
	while (it != lt.end())
	{
		*it *= 2;
		++it;
	}
	cout << endl;

	//遍历：范围for
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

}

int main()
{
	test_list1();
	return 0;
}

在这里插入图片描述

头插和尾部弹出

#include<iostream>
#include<list>
using namespace std;

void test_list1()
{
	list<int> lt;
	//插入数据（尾插）
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);

	//遍历：迭代器
	list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	it = lt.begin();        //迭代器修改值
	while (it != lt.end())
	{
		*it *= 2;
		++it;
	}
	cout << endl;

	//遍历：范围for
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	//头插和尾部弹出
	lt.push_front(10);
	lt.push_front(10);
	lt.push_front(10);

	lt.pop_back();
	lt.pop_back();

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;
}

int main()
{
	test_list1();
	return 0;
}

在这里插入图片描述

insert和erase的指针失效问题

在使用std::list的insert()和erase()函数时，insert()不会出现指针失效的问题。这是因为std::list使用链表结构实现，插入和删除元素时只需要调整节点的指针，不会涉及内存的重新分配和移动。

具体来说，当调用insert()函数插入一个元素时，它会在指定位置之前插入一个新的节点，并调整前一个节点和后一个节点的指针，使得链表仍然保持正确的连接关系。插入操作后，原来存在的节点和迭代器仍然有效。

当调用erase()函数删除一个元素时，它会删除指定位置的节点，指针的位置会失效。

void test_list2()
{
	list<int> lt;
	//插入数据（尾插）
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);

	auto pos = find(lt.begin(), lt.end(), 3);
	if (pos != lt.end())     //pos不会失效
	{
		lt.insert(pos, 30);
		*pos *= 100;
	}

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	pos = find(lt.begin(), lt.end(), 4);
	if (pos != lt.end())     //pos会失效
	{
		lt.erase(pos);
		//cout << *pos << " ";   此时的pos已经被删除  成了野指针  
	}

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;
}
int main()
{
	test_list2();
	return 0;
}

自定义实现list

在这里插入图片描述

基本框架

#pragma once

namespace b
{
	template<class T>
	class list_node
	{
		T _data;             //存放数据
		list_node<T>* _next; //指向下一个结点
		list_node<T>* _prev; //指向前一个结点
		
		list_node(const T& x = T())   //构造函数
			:_data(x)
			, _next(nullptr)
			, _prev(nullptr)
		{}
	};

	template<class T>
	class list
	{
		typedef; list_node<T> Node;
	public:
		list()
		{
			_head = new Node;
			_head->_next = _head;
			_head->prev = _head;
		}

	private:
		Node* _head;  //头结点
	};
}

实现push_back()

将结点信息传入push_back()函数，然后将头结点 尾部结点 和新节点的指针做一一对应即可

		void push_back(const T& x)
		{
			Node* tail = _head->_prev;
			Node* newnode = new Node(x);
			//_head tail newnode
			tail->_next = newnode;
			newnode->prev = tail;
			newnode->_next = _head;
			_head->_next = newnode;
		}

iterator


	template<class T>
	struct _list_iterator
	{
		typedef list_node<T> Node;
		Node* _node;
		
		_list_iterator(Node* node)
			:_node(node)
		{}

#pragma once

namespace b
{
	template<class T>
	class list_node
	{
		T _data;             //存放数据
		list_node<T>* _next; //指向下一个结点
		list_node<T>* _prev; //指向前一个结点

		list_node(const T& x = T())   //构造函数
			:_data(x)
			, _next(nullptr)
			, _prev(nullptr)
		{}
	};

	template<class T>
	struct _list_iterator
	{
		typedef list_node<T> Node;
		Node* _node;
		
		_list_iterator(Node* node)
			:_node(node)
		{}
	};
//
//
//对list中的迭代器进行补充
	template<class T>
	class list
	{
		typedef; list_node<T> Node;
	public:
		typedef _list_iterator<T> iterator;
		
		iterator begin()
		{
			return iterator(_head->_next);
		}
		iterator end()
		{
			return iterator(_head);
		}
		
		list()
		{
			_head = new Node;
			_head->_next = _head;
			_head->prev = _head;
		}

		void push_back(const T& x)
		{
			Node* tail = _head->_prev;
			Node* newnode = new Node(x);
			//_head tail newnode
			tail->_next = newnode;
			newnode->prev = tail;
			newnode->_next = _head;
			_head->_next = newnode;
		}

	private:
		Node* _head;  //头结点
	};
}

iterator中的运算符重载

	template<class T>
	struct _list_iterator
	{
		typedef list_node<T> Node;
		typedef _list_iterator<T, Ref, Ptr> iterator;
		Node* _node;
		
		_list_iterator(Node* node)
			:_node(node)
		{}

		bool operator!=(const iterator& it) const
		{
			return _node != it._node;
		}
		bool operator==(const iterator& it)const
		{
			return _node == it.node;
		}
		//*it it.operator*()  解引用
		T& operator*()
		{
			return _node->next;
		}

      T* operator->() { return &(operator*()); }
		// ++it
		iterator& operator++()
		{
			return _node->_next;
		}
	};

在使用T* operator->() { return &(operator*()); }输出cout<<it->?时实际上有两个->-> 为it->->? 编译器优化了一个
在这里插入图片描述
在std::list中，运算符重载->的作用是用于访问链表中节点的成员。当我们使用->操作符访问链表中的节点时，实际上是访问了节点的指针，并通过该指针来访问节点的成员。

例如，假设有一个std::list对象myList，其中包含了若干个节点，每个节点都有一个成员变量data。我们可以通过迭代器来遍历链表，并使用->操作符访问每个节点的data成员。示例如下：

#include <iostream>
#include <list>

struct Node {
    int data;
    Node(int d) : data(d) {}
};

int main() {
    std::list<Node> myList;
    myList.push_back(Node(1));
    myList.push_back(Node(2));
    myList.push_back(Node(3));

    for (auto it = myList.begin(); it != myList.end(); ++it) {
        std::cout << it->data << " ";
    }
    std::cout << std::endl;

    return 0;
}

在上述示例中，我们定义了一个结构体Node，其中包含一个整型成员变量data。然后，我们创建了一个std::list对象myList，并向其中插入了三个节点。接下来，我们使用迭代器遍历链表，并通过->操作符访问每个节点的data成员，将其输出到控制台。

编译器在优化代码时，可能会对->操作符进行一些优化，例如将其转换为直接访问成员的方式，从而提高代码的执行效率。这种优化是由编译器自动完成的，我们无需手动干预。

需要注意的是，->操作符的优化可能因编译器和编译选项的不同而有所差异。在实际使用中，我们应该根据具体情况进行测试和评估，以确保代码的正确性和性能。

const iterator

此时我们的iterator并不能处理const类型

#pragma once

namespace b
{
	template<class T>
	class list_node
	{
		T _data;             //存放数据
		list_node<T>* _next; //指向下一个结点
		list_node<T>* _prev; //指向前一个结点

		list_node(const T& x = T())   //构造函数
			:_data(x)
			, _next(nullptr)
			, _prev(nullptr)
		{}
	};

	//template<class T>
	//为处理const类型   改为像指针一样的对象
	template<class T,class Ref,class Ptr>
	struct _list_iterator
	{
		typedef list_node<T> Node;
		typedef _list_iterator<T, Ref, Ptr> iterator;
		Node* _node;
		
		_list_iterator(Node* node)
			:_node(node)
		{}

		bool operator!=(const iterator& it) const
		{
			return _node != it._node;
		}
		bool operator==(const iterator& it)const
		{
			return _node == it.node;
		}
		//*it it.operator*()  解引用
		Ref operator*()
		{
			return _node->next;
		}
		
		Ref operator->() { return &(operator*()); }

		// ++it
		iterator& operator++()
		{
			return _node->_next;
		}
	};

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

		void push_back(const T& x)
		{
			Node* tail = _head->_prev;
			Node* newnode = new Node(x);
			//_head tail newnode
			tail->_next = newnode;
			newnode->prev = tail;
			newnode->_next = _head;
			_head->_next = newnode;
		}

	private:
		Node* _head;  //头结点
	};
}

insert

思路和push_back类似

		void insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;

			Node* newnode = new Node(x);
			//prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->next = cur;
			cur->_prev = newnode;
			
			return iterator(newnode);
		}

push_front

利用insert实现

		void push_front(const T& x)
		{
			insert(begin(), x);
		}

erease

void erase(iterator pos)
		{
			assert(pos != end());

			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;

			prev->_next = next;
			next->prev = prev;
			delete cur;

			return iterator(next);
		}

pop_front

		void pop_front()
		{
			erase(begin());
		}

编译器报错

为不发生报错 要在自定义结构体iterator中加入

		typedef biddirectional_iterator_tag iterator_category;
		typedef T value_type;
		typedef Ptr pointer;
		typedef Ref reference;
		typedef ptrdiff_t difference_type;

具体原因未知？

完整代码

#pragma once

namespace b
{
	template<class T>
	class list_node
	{
		T _data;             //存放数据
		list_node<T>* _next; //指向下一个结点
		list_node<T>* _prev; //指向前一个结点

		list_node(const T& x = T())   //构造函数
			:_data(x)
			, _next(nullptr)
			, _prev(nullptr)
		{}
	};

	//template<class T>
	//为处理const类型   改为像指针一样的对象
	template<class T,class Ref,class Ptr>
	struct _list_iterator
	{
		typedef list_node<T> Node;
		typedef _list_iterator<T, Ref, Ptr> iterator;

		typedef biddirectional_iterator_tag iterator_category;
		typedef T value_type;
		typedef Ptr pointer;
		typedef Ref reference;
		typedef ptrdiff_t difference_type;

		Node* _node;
		
		_list_iterator(Node* node)
			:_node(node)
		{}

		bool operator!=(const iterator& it) const
		{
			return _node != it._node;
		}
		bool operator==(const iterator& it)const
		{
			return _node == it.node;
		}
		//*it it.operator*()  解引用
		Ref operator*()
		{
			return _node->next;
		}
		
		Ref operator->() { return &(operator*()); }

		// ++it
		iterator& operator++()
		{
			return _node->_next;
		}
	};

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

		void push_back(const T& x)
		{
			Node* tail = _head->_prev;
			Node* newnode = new Node(x);
			//_head tail newnode
			tail->_next = newnode;
			newnode->prev = tail;
			newnode->_next = _head;
			_head->_next = newnode;
		}

		void push_front(const T& x)
		{
			insert(begin(), x);
		}

		void insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;

			Node* newnode = new Node(x);
			//prev newnode cur
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->next = cur;
			cur->_prev = newnode;
			
			return iterator(newnode);
		}
		
		void pop_front()
		{
			erase(begin());
		}

		void erase(iterator pos)
		{
			assert(pos != end());

			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;

			prev->_next = next;
			next->prev = prev;
			delete cur;

			return iterator(next);
		}
	private:
		Node* _head;  //头结点
	};
}
ls-R
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang slice 最后一个元素_Go 常见的数据结构 Slice
weixin_39714191的博客
12-27 2336
Slice 又称动态数组，依托数组实现，可以方便的进行扩容，传递等，实际使用中比数组更灵活。因为灵活，所以要了解其内部实现机制，不然会遇到各种莫名的异常现象。所以，今天来了解下 Slice 的实现原理。1、热身1.1、题目一下面程序输出什么？funcmain(){vararray[10]intvarslice=array[5:6]fmt.Println("lengt...
【C++】list 的介绍和使用
joy.728的博客
12-17 927
list 是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。list 的底层是带头双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。list 与 forward_list 非常相似：最主要的不同在于forward_list 是单链表，只能朝前迭代，已让其更简单高 效。与其他的序列式容器相比（array，vector，deque），list 通常在任意位置进行插入、移除元素的执行效率更好。
C++中的std::list迭代器
最新发布
woods12351的博客
05-12 352
在C++编程中，std::list是一个强大的容器，它基于双向链表实现，提供了高效的插入和删除操作。然而，当我们需要遍历std::list中的元素时，迭代器（Iterator）就成为了我们的得力助手。我们将深入探索C++中std::list的迭代器，并了解它们的工作原理和常见用法。
点击list 得到索引方法
jackchen的专栏
11-17 1241
index = list.locationToIndex(e.getPoint());
C++ 链表操作（建立、添加、删除、查找、排序、索引等）
04-20
C++ 链表操作（建立、添加、删除、查找、排序、索引等）； 包含：结构体、纯虚接口、继承等技术；
C++容器-list、set、map
lyxawdn的博客
03-27 3211
一、list容器 1、list基本概念 list（链表）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。 链表由结点构成，结点之间是独立的，由数据域和指针域构成。 优点：链表可以对任意位置进行快速插入和删除元素，采用动态存储分配，不会造成内存的浪费和溢出。 缺点：容器遍历速度，没有数组快，且占用空间比数组大。 在STL中，链表是一个双向循环链表。 由于链表的存储方式并不是连续的内存空间， 因此链表list中的迭代器只支持前移和后移，属于双向迭代器。 2、list构造函数
C++学习课件
04-16
本套C++学习课件专为初学者设计，旨在帮助你从零开始，逐步掌握C++的基本概念和编程技巧。 首先，C++的学习需要了解其基本语法结构，包括变量声明、数据类型、运算符、流程控制语句（如if条件语句、for循环、while...
c++学习
05-20
以上就是从给定的实验文件名中推测出的C++学习可能涉及的主要知识点。每个主题都包含了大量的细节和实践应用，深入学习和理解这些概念是成为熟练C++程序员的关键步骤。在实践中，通过编写代码、调试和解决实际问题，...
C++实现的泛型List类分享
09-04
总的来说，这个ListSZ类的实现提供了一个学习C++泛型编程和内存管理的良好示例，同时也展示了如何在没有内置泛型容器库的情况下构建自己的泛型数据结构。对于想要深入理解C++和提升编程技巧的开发者来说，这样的实践...
c++学习c++学习.zip
06-25
"c++学习c++学习.zip"这个压缩包文件显然是为了帮助学习者掌握C++语言而准备的，其中可能包含了源代码、教程文档、示例程序等内容。 在C++的学习过程中，首先需要理解基本语法，这包括变量声明、数据类型（如int, ...
C++学习练习 C++资源
07-27
在"C++学习练习"资源中，我们可以预期包含一系列帮助初学者和进阶者提升C++技能的材料。cpp-master这个文件名可能表示这是一个关于C++的项目仓库或者教程集合，通常在开源社区中，"master"分支代表了项目的主线代码...
C++ STL容器之list
hestyle的博客
05-02 1124
C++ list 容器 定义于头文件 <list> 申明 template<class T, class Allocator = std::allocator<T> > class list; std::list 是支持常数时间从容器任何位置插入和移除元素的容器。不支持快速随机访问。它通常实现为双向链表。与 std::forward_list 相比，此容器提供...
c++ std list 遍历循环中删除成员
u010433190的博客
06-29 1288
不可以直接删除，会导致迭代器失效，然后引发段错误，
【C++】STL---list基本用法介绍
m0_74352571的博客
07-23 1377
详细介绍【C++】STL---list基本用法。
STL--迭代器（iterator）
weixin_34044273的博客
05-03 675
指针与数组 指针与其它数据结构呢？比如说链表？ 存储空间是非连续的。不能通过对指向这种数据结构的指针做累加来遍历。 能不能提供一个行为类似指针的类，来对非数组的数据结构进行遍历呢？这样我们就能够以同样的方式来遍历所有数据结构（容器）。 迭代器(Iterator)是指针(pointer)的泛化，它允许程序员以相同的方式处理不同的数据结构(容器)。STL中有五种类型的迭代器，它们分别满...
STL list迭代器实现
c++
07-18 1038
list list是一个线性双向链表结构，它的数据由若干个节点构成，每一个节点都包括一个信息块（即实际存储的数据）、一个前驱指针和一个后驱指针。它无需分配指定的内存大小且可以任意伸缩，这是因为它存储在非连续的内存空间中，并且由指针将有序的元素链接起来。由于其结构的原因，list 随机检索的性能非常的不好，因为它不像vector 那样直接找到元素的地址，而是要从头一个一个的顺序查找，这样目标元素越靠...
简单说明C++ STL list中的迭代器（iterator）
Z's blog
10-10 1万+
简单说明C++ STL list中的迭代器（iterator） 这篇文章主要讨论在使用list方法后迭代器的活动和一些注意点。 先说结论： 只有resize()，erase()和remove()方法可能会对iterator造成影响，其他方法均不改变iterator原本指向的空间。 详细见下文 0. 头文件和迭代器 如果想在C++中使用list容器，需要准备这些 #include <iostream> #include <list> using namespace std; list
STL STD::list使用说明
热门推荐
lanyzh0909的专栏
05-15 5万+
stl list使用说明 使用标准的std::list进行容器数据处理时，操作比较底层。我们可以，减少引用标准MFC标准库，减少系统的大小，但同时也存在有不方便的操作之处，这里同大家分享一些使用心得......       在使用std::list::iterator链表遍历器进行访问 list     STL 中的list 就是一 双向链表，可高效
C++语法基础学习指南
6. **STL（Standard Template Library）**：STL是C++的标准模板库，包含了一系列高效的数据结构（如vector、list、set）和算法。通过理解和使用STL，开发者可以快速实现常见的数据操作，提高代码的效率和可读性。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值