[转] C++ STL标准库： std::list使用介绍、用法详解

最新推荐文章于 2024-04-27 11:18:51 发布
最新推荐文章于 2024-04-27 11:18:51 发布
阅读量3.2k 收藏 16
点赞数 1
分类专栏： C++基础 文章标签： 链表 数据结构 c++
原文链接：https://blog.csdn.net/u014779536/article/details/111301635
版权

文章目录

0. std::list 简介

img

头文件:

#include <list>

模板类list是一个容器，list是由双向链表来实现的，每个节点存储1个元素。list支持前后两种移动方向。

优势： 任何位置执行插入和删除动作都非常快

list与vector的区别：

  1. list不支持随机存取;
  2. 在list的任何位置执行插入和移除都非常快.插入和删除动作不影响指向其它元素的指针,引用,迭代器,不会造成失效;
  3. list不支持随机存取,不提供下标操作符和at()函数;
  4. list没有提供容量,空间重新分配等操作函数,每个元素都有自己的内存;
  5. list也提供了特殊成员函数,专门用于移动元素.

1 std::list 定义对象

list<A> listname;
list<A> listname(size);
list<A> listname(size,value);
list<A> listname(elselist);
list<A> listname(first, last);

2 std::list添加元素

void push_front(const T& x);	// 头部添加
void push_back(const T& x);		// 尾部添加

3 std::list删除元素

void pop_front();		// 头部删除
void pop_back();		// 尾部删除

4 std::list容器容量

size_type size() const;				// 返回元素个数
size_type max_size() const;			// 返回list对象最大允许容量
void resize(size_type n, T x=T());	// 调整list对象的大小

5 std::list迭代器

begin()		// 返回指向容器中第一个元素的双向迭代器。
end()		// 返回指向容器中最后一个元素所在位置的下一个位置的双向迭代器。
rbegin()	// 返回指向最后一个元素的反向双向迭代器。
rend()		// 返回指向第一个元素所在位置前一个位置的反向双向迭代器。
cbegin()	// 和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
cend()		// 和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
crbegin()	// 和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
crend()		// 	和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。

程序示例:

#pragma warning(disable:4786)
#include <iostream>
#include <list>
#include <algorithm>
#include <string>
//#include <iomanip.h>

using namespace std;

template <class T>void print(const T& Ele)
{
	cout<<" "<<Ele<<";"<<endl;
}

// 格式化输出
void Print_D(double& Ele)
{
	cout.width(5);			// 宽度5
	cout.precision(1);		// 保留1位小数
	cout<<std::fixed<<Ele<<", ";
}
void Print_I(int& Ele)
{
	cout<<Ele<<",  ";
}

void main()
{
	//上定义双向队列
	list<string>mylist_string;
	list<double>mylist_double(6);
	
	//---------初始化mylist_string
	mylist_string.push_front("1:  Jack");
	mylist_string.push_front("2:  Tom");
	mylist_string.push_front("3:  Mike");

	//---------初始化mylist_double
	mylist_double.push_front(10.0);
	mylist_double.push_front(20.0);
	mylist_double.push_front(30.0);
	mylist_double.push_front(40.0);
	mylist_double.push_front(50.0);

	//下述是三种容器定义形式
	list<int> mylist_int(6,0);			// 6个0：0 0 0 0 0 0
	list<double>mylist_double2(6,0.0);	// 6个0.0：0.0 0.0 0.0 0.0 0.0 0.0
	list<int>elselist(mylist_int);		// 以其它双向队列初始化
	list<double>Iterlist(mylist_double.begin(),mylist_double.end());	// 以其他队列初始化

	//----输出各个容器中的元素
	cout<<"打印 mylist_string:"<<endl;
	list<string>::iterator iter_String;	// 迭代器
	for(iter_String=mylist_string.begin();iter_String!=mylist_string.end();iter_String++)
	{
		string temp=*iter_String;
		print(temp);
	}
	cout<<"打印 mylist_double:"<<endl;
	for_each(mylist_double.begin(),mylist_double.end(),Print_D);
	cout<<endl;


	cout<<"打印 mylist_double2:"<<endl;
	for_each(mylist_double2.begin(),mylist_double2.end(),Print_D);
	cout<<endl;

	cout<<"打印 Iterlist:"<<endl;
	for_each(Iterlist.begin(),Iterlist.end(),Print_D);
	cout<<endl;

	cout<<"打印 mylist_int:"<<endl;
	for_each(mylist_int.begin(),mylist_int.end(),Print_I);
	cout<<endl;

	cout<<"打印 elselist:"<<endl;
 	for_each(elselist.begin(),elselist.end(),Print_I);
	cout<<endl;

	//各容器的容量
	int size=mylist_string.size();
	int maxsize=mylist_string.size();
	mylist_string.resize(5);

	size=mylist_double.size();
	maxsize=mylist_double.max_size();
	mylist_double.resize(5);

	size=mylist_double2.size();
	maxsize=mylist_double2.max_size();
	mylist_double2.resize(5);

	size=Iterlist.size();
	maxsize=Iterlist.max_size();
	Iterlist.resize(5);

	size=mylist_int.size();
	maxsize=mylist_int.max_size();
	mylist_int.resize(5);

	size=elselist.size();
	maxsize=elselist.max_size();
	elselist.resize(5);

	//----再次输出各个容器中的元素
	cout<<"打印 mylist_string:"<<endl;
			     for(iter_String=mylist_string.begin();iter_String!=mylist_string.end();iter_String++)
	{
		string temp=*iter_String;
		print(temp);
	}
	cout<<"打印 mylist_double:"<<endl;
	for_each(mylist_double.begin(),mylist_double.end(),Print_D);
	cout<<endl;

	cout<<"打印 mylist_double2:"<<endl;
	for_each(mylist_double2.begin(),mylist_double2.end(),Print_D);
	cout<<endl;

	cout<<"打印 Iterlist:"<<endl;
	for_each(Iterlist.begin(),Iterlist.end(),Print_D);
	cout<<endl;

	cout<<"打印 mylist_int:"<<endl;
	for_each(mylist_int.begin(),mylist_int.end(),Print_I);
	cout<<endl;

	cout<<"打印 elselist:"<<endl;
 	for_each(elselist.begin(),elselist.end(),Print_I);
	cout<<endl;


	//使用迭代器相关的函数
	list<double>::iterator Iter_D;
	list<double>::reverse_iterator Iter_rD;
	cout<<"打印 mylist_double 所有元素："<<endl;
	for_each(mylist_double.begin(),mylist_double.end(),Print_D);
	cout<<endl;

	double tmp=0.0;
	Iter_D=mylist_double.begin();
	tmp=*Iter_D;
	cout<<"打印 mylist_double 的 begin:"<<endl;
	cout<<tmp<<endl;

	Iter_rD=mylist_double.rbegin();
	tmp=*Iter_rD;
	cout<<"\r\n打印 mylist_double 的 rbegin:"<<endl;
	cout<<tmp<<endl;

 	Iter_D=mylist_double.end();
	Iter_D--; // 必须--，end为指向最后一个元素所在位置后一个位置
	tmp=*Iter_D;
	cout<<"打印 mylist_double 的 end:"<<endl;
	cout<<tmp<<endl;

	Iter_rD=mylist_double.rend();
	Iter_rD--; // 必须--，rend为指向第一个元素所在位置前一个位置
	tmp=*Iter_rD;
	cout<<"打印 mylist_double 的 rend:"<<endl;
	cout<<tmp<<endl;

 	tmp=mylist_double.front();
	cout<<"打印 mylist_double 的 front:"<<endl;
	cout<<tmp<<endl; //
	//cout<<mylist_double.front()<<endl;

 	tmp=mylist_double.back();
	cout<<"打印 mylist_double 的 back:"<<endl;
	cout<<tmp<<endl; 
}

image-20201216190325162

6 std::list判断是否为空

bool empty() const;


#include <iostream>
#include <list>

using namespace std;

void main()
{
	list<double>mylist;
	mylist.push_back(10.2);
	bool empty=0;
	if(mylist.empty())
		cout<<"The list is empty!"<<endl;
	else
	{
		empty=mylist.empty();
		cout<<mylist.front()<<", "<<empty<<endl;
	}
}

image-20201216190457554

7 std::list元素的存取和访问

list型容器不提供成员函数at()和操作符operator[],可以使用迭代器进行元素的访问.

#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

void print(double& Ele)
{
	cout<<Ele<<" ,";
}

void main()
{
	// 初始化list
	list<double>mylist;
	mylist.push_back(11.1);
	mylist.push_back(21.5);
	mylist.push_back(31.6);
	mylist.push_back(41.7);

	int count=mylist.size();	// 获取大小
	for_each(mylist.begin(),mylist.end(),print); // 遍历打印


	cout<<endl;
	list<double>::iterator Iter_S;
	Iter_S=mylist.begin();
	cout<<"The third element is "<<*(++(++(++Iter_S)))<<endl;
}

image-20201216190919914

8 std::list元素重置

list型容器提供了可以重置元素值的成员函数assign(),原型如下:

void assign(const_iterator first, const_iterator last);
void assign(size_type n, const T& x=T());

使用方法:

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

// 打印队列所有元素
void print(list<double>& mylist)
{
	list<double>::iterator Iter;
	mylist.reverse();
	for(Iter=mylist.begin();Iter!=mylist.end();Iter++)
	{   
		cout<<*Iter<<",  ";
	}
	cout<<endl;
}

void main()
{
	list<double> list_One,list_Two, list_Three;

	// 初始化 list_One
	double Ele=0.0;
	for(int i=0;i<10;i++)
	{ 
		Ele=i+i/10.0;
		list_One.push_front(Ele);
	}
	print(list_One);

	// 初始化 list_Two
	list_Two.assign(5,5.6);
	print(list_Two);

	// 初始化 list_Three
	list_Three.assign(list_One.begin(),list_One.end());
	print(list_Three);
}

image-20201216191556579

9 std::list 交换两个容器的内容

list提供了成员函数swap().

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

void print(list<double>& mylist)
{
	list<double>::iterator Iter;
	mylist.reverse();
	for (Iter = mylist.begin(); Iter != mylist.end(); Iter++)
	{
		cout << *Iter << ",  ";
	}
	cout << endl;
}

void main()
{
	list<double> list_One, list_Two, list_Three;
	double Ele = 0.0;
	for (int i = 0; i < 10; i++)
	{
		Ele = i + i / 10.0;
		list_One.push_front(Ele);
	}
	cout << "List_One 输出:" << endl;
	print(list_One);

	list_Two.assign(5, 5.6);
	cout << "List_Two 输出:" << endl;
	print(list_Two);

	list_Three.assign(list_One.begin(), list_One.end());
	cout << "list_Three 输出:" << endl;
	print(list_Three);

	/******** list_One与list_Two交换 **********/
	list_One.swap(list_Two);
	cout << "list_one和list_Two交换之后：" << endl;

	cout << "List_One 输出:" << endl;
	print(list_One);

	cout << "List_Two 输出:" << endl;
	print(list_Two);

	/******** list_One与list_Three交换 **********/
	swap(list_One, list_Three);
	cout << "list_one和list_Three交换之后：" << endl;

	cout << "List_One 输出:" << endl;
	print(list_One);

	cout << "list_Three 输出:" << endl;
	print(list_Three);
}

image-20201216192040361

10 std::list元素的插入和删除

image-20201216192229458

insert()的原型:

image-20201216192328148

erase()的原型:

image-20201216192405875

使用示例:

#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

void OutToScreen(int& Ele)
{
	cout<<Ele<<", ";
}

void main()
{
	// 初始化mylt
	list<int> mylt;
	for(int i=0;i<10;i++)
		mylt.push_back(i);

	// 打印
	for_each(mylt.begin(),mylt.end(),OutToScreen);
	cout<<endl;
	cout<<"---------------------------"<<endl;

	// 从尾部删除：
	while(!mylt.empty())
	{
		mylt.pop_back();
		for_each(mylt.begin(),mylt.end(),OutToScreen);
		cout<<endl;
	}

	// 重新初始化
	mylt.clear();
	for(int j=0;j<10;j++)
		mylt.push_back(j);

	// 打印
	for_each(mylt.begin(),mylt.end(),OutToScreen);
 	cout<<endl;
	cout<<"---------------------------"<<endl;

	// 从头部删除
	while(!mylt.empty())
	{
		mylt.erase(mylt.begin());
		for_each(mylt.begin(),mylt.end(),OutToScreen);
		cout<<endl;
	}
}

image-20201216192606245

11 std::list运算符函数

  • operator ==:判断两个list是否相等
  • operator <:判断两个list容器是否"前者小于后者"
  • operator !=:判断两个list容器是否不相等
  • operator <=:判断两个list容器是否"前者小于或等于后者"
  • operator >:依次类推
  • operator >=:依次类推

使用示例:

#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

void print(int& Ele)
{   
	cout <<Ele<<" ";
}

void main()
{
	// 初始化L1,L2
	list<int> L1,L2;
	L1.push_back(1);
	L1.push_back(2);
	L2.assign(L1.begin(),L1.end());

	cout<<"打印 list L1: ";
	for_each(L1.begin(),L1.end(),print);
	cout<<endl;

	cout<<"打印 list L2: ";
 	for_each(L2.begin(),L2.end(),print);
	cout<<endl;

	// 判断是否相等
	if(L1==L2)
		cout<<"L1 和 L2 相等!"<<endl;
	L2.push_back(3);
	L1.push_back(1);

	cout<<"打印 list L1: ";
 	for_each(L1.begin(),L1.end(),print);
	cout<<endl;

	cout<<"打印 list L2: ";
 	for_each(L2.begin(),L2.end(),print);
	cout<<endl;

	// 判断大小
	if(L1<L2)
		cout<<"L1 小于 L2."<<endl;
 	else if(L1>L2)
		cout<<"L1 大于 L2."<<endl;

	if(L1!=L2)
		cout<<"L1 不等于 L2."<<endl;
}

image-20201216193300692

12 std::list merge()和sort()

void merge(list& x);
void merge(list& x, greater<T> pr);

void sort();
void sort(greater<T>pr);

使用示例:

#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

void print(int& Ele)
{
	cout<<Ele<<" ";
}

void main()
{
	// 初始化L1,L2,L3
	list<int> L1,L2,L3;
	list<int>::iterator I1,I2,I3;
	L1.push_back(1);
	L1.push_back(5);
	L2.push_back(2);
	L2.push_back(3);
	L3.push_back(7);
	L3.push_back(8);

	// 打印 L1,L2,L3
	cout<<"L1 : ";
	for_each(L1.begin(),L1.end(),print);
	cout<<endl;
	cout<<"L2 : ";
	for_each(L2.begin(),L2.end(),print);
	cout<<endl;
	cout<<"L3 : ";
	for_each(L3.begin(),L3.end(),print);
	cout<<endl;

	cout<<"L1 合并 L2 和 L3 :";
	L1.merge(L2);
	L1.merge(L3);
	for_each(L1.begin(),L1.end(),print);  //可知，在list合并之后，所有元素自动按从小到大排序
	cout<<endl;

	L1.sort(greater<int>());		      //所有元素自动按从大到小排序
	cout<<"L1 (从大到小排序): ";
	for_each(L1.begin(),L1.end(),print);  
	cout<<endl;

	L1.sort();                            //默认按从小到大排序
	cout<<"L1 (从小到大排序): ";
	for_each(L1.begin(),L1.end(),print);  //所有元素自动按从大到小排序
	cout<<endl;
}

image-20201216193557273

13 std::list remove() 和 remove_if()

void remove(const Type& _Val);
template <class Pred> void remove_if(Pred pr);

使用示例:

#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

void print(int& Ele)
{
	cout<<Ele<<",  ";
}

// 判断是否为偶数
bool is_Even(int & Ele)
{
	return (Ele%2==1);
}

// 初始化列表
void Origin(list<int>& L, int num)
{
	int temp;
	L.clear();
	for(int i=0;i<num;i++)
	{
		temp=i+1;
		L.push_back(temp);
	}
	for_each(L.begin(),L.end(),print);
	cout<<endl;
}

void main()
{
	list<int> L1;
	Origin(L1,9);	// 1 2 3 4 5 6 7 8 9

	// 添加一个9
	int temp;
	temp=9;
	L1.push_back(temp);

	// 添加一个8
	temp=8;
	L1.push_back(temp);

	cout<<"Ouput the list \'L1\':"<<endl;
	for_each(L1.begin(),L1.end(),print);
	cout<<endl;

	// 删除9
	L1.remove(9);
	cout<<"Ouput the list \'L1\':"<<endl;
	for_each(L1.begin(),L1.end(),print);
	cout<<endl;

	// 删除非偶数
	L1.remove_if(is_Even);
	cout<<"Ouput the list \'L1\':"<<endl;
	for_each(L1.begin(),L1.end(),print);
	cout<<endl;
}

image-20201216194414167

14 std::list splice()

// entire list (1)	
void splice (const_iterator position, list& x);
void splice (const_iterator position, list&& x);
// single element (2)	
void splice (const_iterator position, list& x, const_iterator i);
void splice (const_iterator position, list&& x, const_iterator i);
// element range (3)	
void splice (const_iterator position, list& x,
             const_iterator first, const_iterator last);
void splice (const_iterator position, list&& x,
             const_iterator first, const_iterator last);

示例:

#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

void print(int& Ele)
{
	cout<<Ele<<" ";
}

void main()
{
	// 初始化L1,L2,L3,L0
	list<int> L1,L2,L3,L0;
	//list<int>::iterator I1,I2,I3;
	L1.push_back(1);
	L1.push_back(5);
	L2.push_back(2);
	L2.push_back(3);
	L3.push_back(7);
 	L3.push_back(8);
 	L0.push_back(9);
 	L0.push_back(-1);

	// 打印 L1,L2,L3,L0
	cout<<"L1 : ";
	for_each(L1.begin(),L1.end(),print);
	cout<<endl;
 	cout<<"L2 : ";
	for_each(L2.begin(),L2.end(),print);
	cout<<endl;
	cout<<"L3 : ";
	for_each(L3.begin(),L3.end(),print);
	cout<<endl;
	cout<<"L0 : ";
	for_each(L0.begin(),L0.end(),print);
	cout<<endl;

 	cout<<"L1 合并 L2:";
	L1.splice(L1.end(),L2);
	for_each(L1.begin(),L1.end(),print);
	cout<<endl;

 	cout<<"L2 : ";
	for_each(L2.begin(),L2.end(),print);
	cout<<endl;

 	cout<<"L1 合并 L0 :";
	L1.splice(L1.end(),L0,(++L0.begin()));
	for_each(L1.begin(),L1.end(),print);
	cout<<endl;

 	cout<<"L0 : ";
 	for_each(L0.begin(),L0.end(),print);
 	cout<<endl;

 	cout<<"L1 合并 L3 :";
	L1.splice(L1.end(),L3,L3.begin(),L3.end());
	for_each(L1.begin(),L1.end(),print);  //可知，在list合并之后，所有元素自动按从小到大排序
	cout<<endl;

	cout<<"L3 : ";
	for_each(L3.begin(),L3.end(),print);
	cout<<endl;

 	L1.sort(greater<int>());		      //所有元素自动按从大到小排序
	cout<<"L1 (从大到小排序): ";
	for_each(L1.begin(),L1.end(),print);  
	cout<<endl;

	L1.sort();                            //默认按从小到大排序
	cout<<"L1 (从小到大排序): ";
	for_each(L1.begin(),L1.end(),print);  //所有元素自动按从大到小排序
	cout<<endl;
}

image-20201216194908034

15 std::list uniqe()

移除相邻重复元素

void uniqe();

示例:

#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

void Print(int& Ele)
{
	cout<<Ele<<" ";
}

void main()
{
	// 初始化L1,L2
	list<int>L1,L2;
	L1.push_back(1);
	L1.push_back(2);
	L1.push_back(3);
	L1.push_back(1);
	L1.push_back(2);
	L1.push_back(3);
	L1.push_back(5);
	L1.push_back(7);
	L2.assign(L1.begin(),L1.end());

	// 打印 L1,L2
	for_each(L1.begin(),L1.end(),Print);
	cout<<endl;
	for_each(L2.begin(),L2.end(),Print);
	cout<<endl;

	// 对L1进行排序，然后去重
	L1.sort();
	L1.unique();
	for_each(L1.begin(),L1.end(),Print);
	cout<<endl;

	// 对L2进行排序，对满足Pred条件的进行删除
	L2.sort();
	not_equal_to<int> Pred;
	L2.unique(Pred);
	for_each(L2.begin(),L2.end(),Print);
	cout<<endl;
}

image-20201216195540038

16 std::list reverse()

实现将容器中所有元素用原来相反的顺序进行排列;

void reverse();

再次注意:list没有提供[]和at()

Zolony
关注
  • 1
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ STL 内 std::{bind/tuple/function} 简单实现
08-25
主要介绍了C++ STL 内 std::{bind/tuple/function} 简单实现,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
std::list 使用
01-26
linux 下 std::list的使用
C++(7): std::list的使用
tecsai的博客
03-26 764
std::list是 C++ 标准模板库（STL）中的一个顺序容器适配器，它提供了双向链表的数据结构。与 std::vector 不同，std::list 不存储连续的元素，因此它可以高效地在中间插入和删除元素，而不需要移动其他元素。
自定义STL std :: allocator替换可提高性能
04-11
通过替代STL std :: allocator的固定块来防止堆碎片错误并提高执行速度
C++ 学习系列 -- std::list
qq_33775774的博客
10-06 1259
list 是 c++ 中的序列式容器，其实现是双向链表，每个元素都有两个指针，分别指向前一个节点与后一个节点链表与数组都是计算机常用的内存数据结构，与数组连续内存空间不一样的地方在于，链表的空间是不连续的，链表是将一块块不连续的内存串联起来使用。正是由于链表的内存不连续这一特点，所以不能像数组一样，可以根据位置随机的访问每个元素，而链表我们压根不知道每个元素的实际位置到底在哪块内存区域。查找某个元素需要遍历整个链表，直到找到目标元素位置，时间复杂度是 O(n)；
C++ STL标准库： std::list使用介绍、用法详解
热门推荐
超级大洋葱的博客
12-16 7万+
文章目录0. std::list 简介1 std::list 定义对象2 std::list添加元素3 std::list删除元素4 std::list容器容量5 std::list迭代器6 std::list判断是否为空7 std::list元素的存取和访问8 std::list元素重置9 std::list 交换两个容器的内容10 std::list元素的插入和删除11 std::list运算符函数12 std::list merge()和sort()13 std::list remove() 和 re
std list
alex1801
03-27 2652
目录 1、list构造 2、元素插入 2.1、insert 2.2、push_back or pop_front 3、访问 3、元素移除 3.1、pop_back or pop_front 3.2、erase 3.3、remove or remove_if 3.4、clear 3.5、resize 4、list特殊函数 4.1、unique 4.2、splise 4.3、sort 4.4、merge 4.5、reverse 4.6、swap List使用一个doubly
STL详解— list类的介绍及使用
qq_61213622的博客
05-20 2804
STL详解— list类的介绍及使用
c++ std::list
肥猫王德福的博客
11-30 1021
重点总结 List是stl实现的双向链表，它允许快速的插入和删除 List一、pandas是什么？ 一、pandas是什么？
STL STD::list使用说明
lanyzh0909的专栏
05-15 5万+
stl list使用说明 使用标准的std::list进行容器数据处理时，操作比较底层。我们可以，减少引用标准MFC标准库，减少系统的大小，但同时也存在有不方便的操作之处，这里同大家分享一些使用心得......       在使用std::list::iterator链表遍历器进行访问 list     STL 中的list 就是一 双向链表，可高效
c++11中关于std::thread的join的详解
08-26
主要介绍了c++11中关于std::thread的join详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
C++ STL std::string详细讲解
01-19
C++ STL std的string详细讲解
std::List使用总结
大山喵写博客的地方
10-13 2万+
List 　　List使用一个doubly linked list(双向串列)管理元素，按惯例，C++标准库并未明定实现方式，只是遵守list的名称、限制和规格。 　　使用list时必须先包含头文件 #include&amp;amp;amp;lt;list&amp;amp;amp;gt; 　　其中的list类型定义于namespace std 中，是一个class template： template&amp;amp;amp;lt; class T,
【C++】STL——list的介绍和使用、list增删查改函数的介绍和使用、push_back、pop_back
Crocodile1006的博客
07-25 2878
STL、list的使用、list的增删查改函数、push_front（在list首元素前插入值为val的元素）pop_front（删除list中第一个元素）push_back（在list尾部插入值为val的元素）pop_back（删除list中最后一个元素）insert（在list position位置中插入值为val的元素）erase（删除list position位置的元素）swap（交换两个list中的元素）clear（清空list中的有效元素）
C++ 列表详解
UiaHaskell的博客
09-17 1466
列表（List）是C++中一种常用的数据结构，用于存储一系列元素。它提供了一种动态大小的容器，可以在运行时添加、删除和访问元素。本文将详细介绍C++中的列表，并提供相应的源代码示例。在C++中，可以使用标准模板库（STL）中的类来创建和操作列表。是一个双向链表，它提供了一系列操作函数和迭代器，方便我们对列表进行操作。要使用，首先需要包含头文件。下面是一个简单的示例，展示了如何创建一个整数类型的列表，并向其中添加一些元素： 在上面的示例中，我们首先创建了一个名为的对象。然后，我们使用函数向列表中添加了三个整数
C++——std::List
zy2317878的博客
01-25 5316
写在前面 这一篇博客系统学习一下C++中List类的相关函数。之所以要学习这个类，是由于LeetCode中做到了Linked List类，虽然在LeetCode中并没有使用到List类的相关函数，而是主要利用链表的数据结构来完成一些内容，或者说，就是从基础的数据结构来实现接下来要学习的一些链表类的函数，比如：插入，删除结点等等。这篇博客的风格内容与之前博客并无两异，所以主要目的还是对List类的...
std::list
qq_44778120的博客
03-03 643
std::list 是支持常数时间从容器任何位置插入和移除元素的容器。不支持快速随机访问。它通常实现为双向链表。与 std::forward_list相比，此容器提供双向迭代但在空间上效率稍低。 在 list 内或在数个 list 间添加、移除和移动元素不会非法化迭代器或引用。迭代器仅在对应元素被删除时非法化。 5.2 成员函数 5.2.1 修改器 函数 说明 clear 清除内容 (公开成员函数) insert 插入元素 (公开成员函数) emplace (C++11) 原位构造元
【数据结构】图的应用（最小生成树、拓扑排序、最短路径等）
最新发布
2201_75475240的博客
04-27 725
本文章介绍数据结构中的图的应用，包括最小生成树的Prim算法和Kruskal算法，拓扑排序和最短路径，且还包含408习题（附有解析）。此外，含有关于Prim算法，Kruskal算法和Dijkstra算法全部具体实现代码。
std::list<double>::iterator
08-30
std::list<double>::iterator是C++中std::list容器的迭代器类型。在C++中，迭代器用于遍历容器中的素。引用中的代码展示了如何使用std::list容器和迭代器进行操作。通过使用std::list<double>::iterator，可以在std::list容器中访问和操作double类型的元素。通过迭代器，可以对容器中的元素进行遍历、添加、删除等操作。在引用中的示例代码中，通过初始化std::list容器，并使用迭代器Iter_S来访问和打印容器中的元素。因此，std::list<double>::iterator是一个用于访问std::list容器中double类型元素的迭代器。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [std::list的使用](https://blog.csdn.net/n567656756765676567/article/details/6741258)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [C++ STL标准库： std::list使用介绍、用法详解](https://blog.csdn.net/u014779536/article/details/111301635)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值