【C++进阶之路】list的基本使用和模拟实现

已于 2023-09-08 22:23:31 修改
阅读量2k 收藏 6
点赞数 6
分类专栏： C++进阶之路 文章标签： c++ list 笔记
于 2023-07-19 18:03:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shun_Hua/article/details/131783823
版权
本文详细介绍了C++标准库中的list容器，包括它的定义、底层原理和迭代器的分类。接着，文章通过示例展示了如何使用list进行插入、删除节点、合并有序链表、转移链表部分以及排序去重等操作。同时，对比了vector和list的排序性能。此外，还探讨了如何模拟实现list的迭代器，包括构造函数、解引用和指针操作。最后，文章提供了自定义list类的源码实现。
摘要由CSDN通过智能技术生成

文章目录

初步认识

 在正式讲解之前,我们先简单的认识一下list

①定义

template < class T, class Alloc = allocator<T> > class list;

同样这里有两个模板参数，第一个是实例化的类型，第二个是空间配置器。

②底层原理

库里的list是采用带头双向循环链表进行实现的。

  • forward_list是单链表

在这里插入图片描述

  • 带哨兵位的头结点，是为了给end()迭代器留位置。

③迭代器的分类

在这里插入图片描述

1.输入迭代器
2.输出迭代器
3.单向迭代器——forward_list,unorder_xxx
4.双向迭代器——list/map/set
5.随机访问迭代器——vector/string/deque

之间的关系：
在这里插入图片描述

  • 从左到右是被包含的关系。

在这里插入图片描述

一、基本使用

1.插入结点元素

	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	lt.push_back(6);

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;
	
	list<int>::iterator it = lt.begin();
	for (size_t i = 0; i < 5; i++)
	{
		it++;
	}
	//在第五个位置的前面插入10
	//第五个位置——是下标为5，也就是第六个元素。
	lt.insert(it,10);


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

在这里插入图片描述

  • 说明：因为list不支持随机访问，因此没有+，+=，[] 运算符重载，但支持++，- -。

  • 这里的迭代器，在插入之后，并没有失效，因为结点的插入是单个申请，单个释放的。不存在 扩容的现象。

2.删除结点元素

void test_list()
{
	list<int> lt;
	lt.push_back(2);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(90);
	lt.push_back(6);
	lt.push_back(7);


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

	//删除所有的偶数结点
	list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		if (*it % 2 == 0)
		{
			it = lt.erase(it);
		}
		else
		{
			it++;
		}
	}

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

}
  • erase在释放之后，迭代器是肯定失效的，因为其所指向的空间都失效了。因此库里采用返回值进行更新迭代器。

3.合并两个有序链表

  • 前提必须是有序的。
void test_list()
{
	list<int> lt;
	lt.push_back(2);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	lt.push_back(6);
	lt.push_back(7);


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

	list<int> lt1;
	lt1.push_back(1);
	lt1.push_back(3);
	lt1.push_back(5);
	lt1.push_back(7);
	lt1.push_back(9);

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

	//将lt1合并到lt上
	lt.merge(lt1);
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

}

在这里插入图片描述

4.将一条链表的某一部分转移到另一条链表

接口：


void splice (iterator position, list& x);
//将x链表转移到另一条链表的pos位置之前
void splice (iterator position, list& x, iterator i);
//将x链表的某个位置的结点移到另一条链表的pos之前
void splice (iterator position, list& x, iterator first, iterator last);
//将x链表的[first,last)的区间移到另一条链表的pos位置之前。

注意：迭代器/迭代器区间不能重合！

list<int> lt;
	lt.push_back(2);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	lt.push_back(6);
	lt.push_back(7);


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

	list<int> lt1;
	lt1.push_back(1);
	lt1.push_back(3);
	lt1.push_back(5);
	lt1.push_back(7);
	lt1.push_back(9);

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

	//将lt1转移到到lt的前面
	lt.splice(lt.begin(),lt1);
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	//将lt的后半部分转移到lt1上
	list<int>::iterator it = lt.begin();
	for (size_t i = 0; i < 5; i++)
	{
		it++;
	}
	lt1.splice(lt1.begin(), lt ,it, lt.end());

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

	//将lt1的第一个结点移到lt的最前面
	lt.splice(lt.begin(), lt1, lt1.begin());

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

5.对链表排序并去重

  • unique去重的前提是有序。
	list<int> lt;
	lt.push_back(2);
	lt.push_back(1);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(2);
	lt.push_back(6);
	lt.push_back(4);
	
	lt.sort();
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	lt.unique();

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

6.vector与list排序的比较

void test_list2()
{
	list<int> lt;
	vector<int> v;
	//设置随机数起点
	srand((unsigned)time(nullptr));
	size_t datas_num = 1000000;
	for (size_t i = 0; i < datas_num; i++)
	{
		int n = rand();
		lt.push_back(n);
		v.push_back(n);
	}
	int begin1 = clock();
	sort(v.begin(), v.end());
	int end1 = clock();
	cout <<"vector:" << (end1 - begin1) << endl;

	int begin2 = clock();
	lt.sort();
	int end2 = clock();
	cout <<"list:" << (end2 - begin2) << endl;
}

在这里插入图片描述

  • 结果：list的排序有点挫，不过如果数据量比较小，可以使用list提供的排序，数据量比较大的话，那就将list的数据拷贝到vector，进行排序，再拷贝回去。
  • 注意：在debug下进行测试可能会得到不一样的结果，因为vector是使用递归的快排进行实现的，如果debug下添加的调试信息会使栈帧的开销较大，从而影响时间的效率。而list的底层原理是归并，虽然也是递归，但调试信息添加的可能较少，因此会较快。而realease版本是发型版本是做了优化的，性能更好。

二、模拟实现

①要点说明

  • 1.为了不与库里面的list冲突，我们需要命名空间对自己实现的类进行封装
  • 2.这里我们实现的框架是按照带头双向循环链表的数据结构进行实现的。
  • 3.为了理解，下面的接口是分开讲解的，最后我会给出源码。

②基本框架

template<class  T>
struct list_node
{
	list_node(const T& val = T())
		:_val(val)
		,_next(nullptr)
		,_prev(nullptr)
	{}

	T _val;
	list_node* _next;
	list_node* _prev;
};

template<class T>
class list
{
	typedef list_node<T> Node;
public:
	
private:
	Node* _head;
	size_t _size;
};

③迭代器

  • 这是list的最关键的部分！

我们先来谈谈是如何实现的，迭代器必然是指向一个结点的指针，但是能完成++操作，以及解引用操作，那该怎么办呢？答案其实很简单——用类进行封装，通过运算符重载实现相应的功能。

简单的迭代器框架：

template<class T>
struct list_iterator
{
	typedef list_iterator<T> iterator;	
	Node* _node;
};

构造函数

list_iterator(Node* val = nullptr)
	:_node(val)
{}
list_iterator(const iterator& lt)
	:_node(lt._node)
{}
  • 析构我们使用默认生成的即可，可千万不要写析构释放迭代器指向的空间，因为迭代器指向的空间属于list。应由list进行管理。

剩下的操作是，类里面进行重载++，-- ,*。

++

//前置
iterator& operator ++() 
{
	_node = _node->_next;
	return *this;
}
//后置
iterator operator ++(int)
{
	list_iterator tmp(_node);
	_node = _node->_next;
	return tmp;
}

- -

//前置
iterator& operator --()
{
	_node = _node->_prev;
	return *this;
}
//后置
iterator operator --(int)
{
	list_iterator tmp(_node);
	_node = _node->_prev;
	return tmp;
}

*

T& operator *()
{
	return _node->_val;
}

这样迭代器的基本功能就实现了，但是const的迭代器该如何实现呢？

是这样么？

typedef const list_iterator<T> const_iterator;

这样迭代器的成员变量不可被修改，即不可以++或者- -，不符合要求，我们想要的只是返回的值不可被修改。

一般都会再拷贝一份进行，将拷贝的迭代器改改，但是我们还可以设置第二个模板参数，这样外面可以这样定义。

template<class T，class Ref> struct list_iterator;
//里面的运算符重载——*
Ref operator *()
{
	return _node->_val;
}

//list里面可以这样定义

typedef list_iterator<T,const T&> const_iterator;
typedef list_iterator<T,T&> iterator;
  • 这样问题就解决了。

->

还有第二个问题，如果迭代器指向的是自定义类型，比如：

struct A
{
	A(int x = 0)
		:_a1(x)
	{}
	int _a1;
};

如果想要访问其成员，直接解引用是不行的。

我们可以这样：

iterator it = lt.begin();
(*it)._a1;

访问其元素。

我们还可以重载-> 进行访问:

T* operator ->()
{
	return &(_node->_val);
}
iterator it = lt.begin();
it->_a1;

这样其实省略了一个箭头，这省略的一个箭头其实是为了美观，编译器在处理时，会自动加上的。

如果是const对象呢？其实处理方式一样的，再加一个模板参数。

更新后的模板，和迭代器:

template<class T,class Ref,class Ptr> struct list_iterator;
Ptr operator ->()
{
	return &(_node->_val);
}
typedef list_iterator<T,const T&,const T*> const_iterator;
typedef list_iterator<T,T&,T*> iterator;

那完整版的迭代器即为:

template<class T,class Ref,class Ptr>
//第一个参数：为了确定Node的类型；
//第二个是为了实现*解引用的const与非const返回值
//第三个是为实现Node成员为结构体对象的指针的访问对象。
struct list_iterator
{
	typedef list_node<T> Node;
	typedef list_iterator<T, Ref, Ptr> self;
	typedef list_iterator<T, T&, T*> iterator;


	list_iterator(Node* val = nullptr)
		:_node(val)
	{}
	list_iterator(const iterator& lt)
		:_node(lt._node)
	{}


	//重载++
	self& operator ++() 
	{
		_node = _node->_next;
		return *this;
	}
	//后置++，为了区别需要重载一下，这里的参数实际上没啥用
	self operator ++(int)
	{
		list_iterator tmp(_node);
		_node = _node->_next;
		return tmp;
	}
	self& operator --()
	{
		_node = _node->_prev;
		return *this;
	}
	self operator --(int)
	{
		list_iterator tmp(_node);
		_node = _node->_prev;
		return tmp;
	}
	bool operator != (const self& it) const
	{
		return _node != it._node;
	}
	bool operator == (const self& it) const//const和非const都能用
	{
		return _node == it._node;
	}		
	Ptr operator ->()
	{
		return &(_node->_val);
	}
	Ref operator *()
	{
		return _node->_val;
	}
	Node* _node;
};

list里的迭代器

iterator begin() 
{
	return _head->_next; 
	//隐式类型转换
}
const_iterator begin()const
{
	return _head->_next;
	
}
iterator end()
{
	return _head;
}
const_iterator end()const
{
	return _head;
}

④insert

//在pos之前插入
void insert(iterator pos, const T& val)
{
	Node* newnode = new Node(val);
	Node* cur = pos._node;
	Node* prev = cur->_prev;

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

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


	_size++;
}

⑤erase

Node* 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;

	_size--;
	return next;
}

⑥push_back

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

	//newnode->_next = _head;
	//newnode->_prev = tail;

	//_head->_prev = newnode;
	//tail->_next = newnode;
	insert(end(), val);
}

⑦push_front

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

⑧pop_front

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

⑨pop_back()

void pop_back()
{
	erase(--end());
}

⑩构造函数

//默认构造函数
list()
{
	_head = new Node;
	_head->_next = _head;
	_head->_prev = _head;
	_size = 0;
}

//拷贝构造
list(const list<T>& lt)
{
	_head = new Node;
	_head->_next = _head;
	_head->_prev = _head;
	_size = 0;

	for (auto e : lt)
	{
		push_back(e);
	}
}

⑪clear

void clear()
{
	iterator it = begin();
	while (it != end())
	{
		it = erase(it);
	}
}

⑫析构函数

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

⑬赋值重载

void swap(list &tmp)
{
	std::swap(_head, tmp._head);
	std::swap(_size, tmp._size);
}
list& operator = (list tmp)
{
	swap(tmp);
	return *this;
}

剩余的接口，过于简单，这里就不再列出了，有兴趣请看源码。

源码

namespace my_list
{
	template<class  T>
	struct list_node
	{
		list_node(const T& val = T())
			:_val(val)
			,_next(nullptr)
			,_prev(nullptr)
		{}

		T _val;
		list_node* _next;
		list_node* _prev;
	};



	template<class T,class Ref,class Ptr>
	struct list_iterator
	{
		typedef list_node<T> Node;
		typedef list_iterator<T, Ref, Ptr> self;
		typedef list_iterator<T, T&, T*> iterator;
		//这个看着确实有点奇怪，写这个为了实现const_iterator转换为
		//非const_itertaor，从而达到类型转换的效果。


		list_iterator(Node* val = nullptr)
			:_node(val)
		{}
		list_iterator(const iterator& lt)
			:_node(lt._node)
		{}


		//重载++
		self& operator ++() 
		{
			_node = _node->_next;
			return *this;
		}
		//后置++，为了区别需要重载一下，这里的参数实际上没啥用
		self operator ++(int)
		{
			list_iterator tmp(_node);
			_node = _node->_next;
			return tmp;
		}
		self& operator --()
		{
			_node = _node->_prev;
			return *this;
		}
		self operator --(int)
		{
			list_iterator tmp(_node);
			_node = _node->_prev;
			return tmp;
		}
		bool operator != (const self& it) const
		{
			return _node != it._node;
		}
		bool operator == (const self& it) const//const和非const都能用
		{
			return _node == it._node;
		}		
		Ptr operator ->()
		{
			return &(_node->_val);
		}
		//加上迭代器为it则调用此函数在底层上实际被翻译为
		//(it.operator->())->结构体成员，忽略了一个->，看起来更加的美观。


		Ref operator *()
		{
			return _node->_val;
		}
		Node* _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;

		list()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}
		list(const list<T>& lt)
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;

			for (auto e : lt)
			{
				push_back(e);
			}
		}
		~list()
		{
			clear();
			delete _head;
		}
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
			//cout << _size << endl;
		}
		iterator begin() 
		{
			//return _head->_next;
			//隐式类型转换为list_itertor
			
			return _head->_next; 
		}
		const_iterator begin()const
		{
			//return _head->_next;
			//隐式类型转换为list_itertor

			return _head->_next;
		}
		iterator end()
		{
			return _head;
			//返回的是_head的拷贝，因此返回对象具有常属性
			
			//隐式类型转换为list_itertor
			//return itrator(_head->next); 
			//匿名对象
		}
		const_iterator end()const
		{
			return _head;
			//返回的是_head的拷贝，因此返回对象具有常属性

			//隐式类型转换为list_itertor
			//return itrator(_head->next); 
			//匿名对象
		}
		void push_back(const T& val)
		{
			//Node* tail = _head->_prev;
			//Node* newnode = new Node(val);

			//newnode->_next = _head;
			//newnode->_prev = tail;

			//_head->_prev = newnode;
			//tail->_next = newnode;
			insert(end(), val);
		}
		//在pos之前插入
		void insert(iterator pos, const T& val)
		{
			Node* newnode = new Node(val);
			Node* cur = pos._node;
			Node* prev = cur->_prev;

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

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


			_size++;
		}
		Node* 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;

			_size--;
			return next;
		}
		void pop_back()
		{
			erase(--end());
		}
		void pop_front()
		{
			erase(begin());
		}
		void push_front(const T& val)
		{
			insert(begin(), val);
		}
		size_t size()
		{
			return _size;
		}
		bool empty()
		{
			return _size == 0;
		}
		void swap(list &tmp)
		{
			std::swap(_head, tmp._head);
			std::swap(_size, tmp._size);
		}
		list& operator = (list tmp)
		{
			swap(tmp);
			return *this;
		}

	private:
		Node* _head;
		size_t _size;
	};
}

总结

 今天的分享就到这里了，如果觉得文章不错，点个赞鼓励一下吧！我们下篇文章再见！

理工小羊
关注
专栏目录
基于Python和C++实现的带加密的联邦学习源码
08-12
在单机上模拟了联邦学习的架构，使用了FED_AVG作为聚合算法。 支持三种运行模式：单机模式，联邦 联邦学习最简单的demo for mnist done 测试加密库对于大数组的性能 done 调试最基本的C++调用python的方法 done C++...
C++ STL标准库与泛型编程（二）分配器、List、Iterator
SimonxxSun的博客
12-20 442
一、分配器 allocators 先谈谈 operator new() 和 malloc() 所有C++平台上的分配动作，最后都会调用malloc()，销毁都会用 free()，然后根据在不同的系统(win linux unix)下去调用不同的 API 实现内存的索取。 malloc()实际分配的空间内存大小会比要求的大，会加上 cookies (记录了本次申请的模块大小) 等额外开销，...
C++Prime入门进阶
02-12
《C++ Primer 入门进阶》是一本专为C++初学者设计的经典教材，由Stanley B. Lippman、Josée Lajoie以及Barbara E. Moo编写。...同时，书籍的版权信息部分也提醒读者尊重知识产权，合法使用和传播书籍内容。
蓝桥杯c++历年真题（只有题目，无解答）
04-29
理解数组和指针的关系，以及如何通过指针操作数组，是C++进阶学习的关键。蓝桥杯题目中，数组和指针的应用广泛，如矩阵操作、字符串处理等。 4. **结构体与类**：结构体是C++中的复合数据类型，类是面向对象编程的...
二级C++分类模拟234.zip
12-17
《二级C++分类模拟234.pdf》是一个针对全国计算机等级考试二级C++语言的模拟试题集，旨在帮助考生熟悉考试格式，提升编程能力和解题技巧。这份资料可能包含了多个部分，如理论知识、编程题型以及历年真题解析，全...
p4:cmu 15213/15513 csapp 深入理解计算机系统（寄存器、标志位/条件码、set指令、大端法小端法、逻辑左右移和算数左右移、字长概念）
shanshan的博客
11-11 502
可以简单记成，setg表示set greater，但是机器指令的参数顺序与我们习惯的顺序不同，机器指令是从右到左比较的。标志位都是一位，他们不是你直接设置的，而是计算机的算术指令自己设置的。在这里是零拓展的意思，将al的一字节的全0拓展为4字节，左边都补0。综上，机器指令的流程是，比较两个数，得到一字节的0或1，然后根据返回类型的字长要求，拓展为相应位数的0或1。这里setg指令根据sf条件码，假设为0，（说明y>x），那么最低位的单个字节也都设为0。将单个寄存器的单个字节根据条件码的值设为1或0。
C++ 中的string类
2201_75357870的博客
11-15 697
end获得的不是最后一个字符的位置，而是最后一个字符的下一个位置！end()-1才是最后一个字符的位置。
c++中，头文件包含iostream.h和`＜iostream＞`的差别
南东先生
11-11 442
`iostream.h` 和`` 包含的是同一个文件，二者在功能上没有差别,只是写法不同。使用``是C++标准推荐的方式。
STL之vecor的使用(超详解)
2302_80220709的博客
11-11 783
如果发生的异地扩容，这时的迭代器就不在指向原来的空间，而就指向一块释放的内存，我们一旦继续访问就会报错，这种现象我们称为迭代器失效。指定位置插入，要注意的是这里不再像string一样，用的size_t 的pos，vector虽然也可以用下标访问，但是为了承接后面STL其他不支持下标访问的容器，所以这边的pos用的是迭代器类型。下面我们开始研究他的使用，为了能够更好的测试，我们先实现一个打印容器元素的函数，vector底层是数组，所以有三种访问方式：下标访问、迭代器访问、范围for（本质也是迭代器）
TI毫米波雷达（五）—— chirp
slyywd的博客
11-14 989
TI的毫米波雷达可以通过定义chirp配置文件来控制一帧中的chirp参数，而且可以在chirp RAM中修改这些配置文件。Chirp配置文件可以作为基础的chirp时序模板，用来生成参数各异的chirp。TI的毫米波雷达可以接收四个不同的chirp配置文件，但是chirp可配置RAM中可以预编程512个独特的chirp。每个chirp都可以引用四个配置文件之一，然后按需要进行细调。一个帧由chirp可配置RAM中起始索引到结束索引间的chirp序列组成，最大可循环255次。
C语言之数组
m0_75253775的博客
11-11 1030
前面我们整理了C语言函数相关知识点,C语言中函数有两种特殊情况。
C++ 编程基础（5）类与对象 | 5.7、友元
个人技术博客
11-14 1009
C++中的友元类与友元函数是一种强大的工具，它们允许程序员在保持类封装性的同时，实现对类内部数据的直接访问。然而，在使用时应谨慎考虑其对封装性、安全性和维护性的影响。只有在确实需要时才使用友元类和友元函数，以避免引入不必要的复杂性和潜在问题。
量化交易backtrader实践(三)_指标与策略篇(8)_股票软件指标参考C
最新发布
AouSdu
11-15 586
主要是学习和实践股票软件中的内置的技术指标公式并且在backtrader中没有的，本节为趋势型指标公式。
lambda 表达式与mutable
王尚权 qq:2515162716
11-15 669
通常情况下，lambda表达式捕获的变量是不可变的，使用mutable关键字可以破坏这种不可变性，允许对捕获变量进行修改。在C++中，mutable关键字和引用捕获方式（&）有不同的用途和效果，它们可以在某些情况下结合使用，但它们的基本功能和影响是不同的。在这个例子中，x既是通过引用捕获的，也是mutable关键字作用的对象。在这个例子中，x是被捕获的变量，mutable关键字使得lambda表达式可以修改x的值。在这个例子中，x是被捕获的变量，mutable关键字使得lambda表达式可以修改x的值。
【代码随想录day29】【C++复健】134. 加油站；135. 分发糖果；860.柠檬水找零；406. 根据身高重建队列
yumenohimiko的博客
11-14 624
感觉贪心的题真的很考验一个人的智商，而我，碰巧没有。134. 加油站偷看了解析思路，但依然因为一个低级失误导致被卡了很久... 并且写出来的代码也非常的麻烦，主要体现在我每到一个新节点，就必须求证似的让iter走完一整圈才算结束，但卡哥的方法一个for循环就结束了。卡哥的思路也相当的清晰：简单来说就是当你一圈下来：1 如果和小于0，那么说明无论如何无解，也不用往后再看了。
扫雷游戏代码分享(c基础)
lb3636363636的博客
11-11 2170
创建两个.c 一个.h。
C++ 编程基础（7）内存模型 | 7.1、内存类型
个人技术博客
11-15 165
在C++编程中，内存管理是一个核心概念。了解不同类型的内存区域有助于我们编写更高效、更安全的代码。本文将详细介绍C++程序的五种主要内存类型：堆、栈、全局区、常量区和二进制代码区。
C++ STL -- 模版
无限大的博客
11-14 1044
在C++编程中，对于不同数据类型的操作，常常需要编写多个相似的函数。例如，在一个项目中，我们可能需要实现一个加法功能。
【蓝桥等考C++真题】蓝桥杯等级考试C++组第13级L13真题原题(含答案)-成绩排序ABCDE
SunMy的博客
11-12 455
【代码】【蓝桥等考C++真题】蓝桥杯等级考试C++组第13级L13真题原题(含答案)-成绩排序ABCDE。
C++进阶之路：全面学习资源从基础到多线程
这个资源库被设计成从基础到高级，覆盖了初学者在学习C++过程中可能遇到的各种问题，包括基本语法、数据结构、算法、类和对象、内存管理、文件操作以及高级特性如模板编程、STL(标准模板库)、多线程并发等。...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值