C++STL容器

最新推荐文章于 2024-04-20 13:15:48 发布
最新推荐文章于 2024-04-20 13:15:48 发布
阅读量179 收藏 1
点赞数 1
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40582808/article/details/109708340
版权

1.函数模板类模板

1.1 函数模板

#include <iostream>
using namespace std;

#if 0
//int类型数据交换
void MySwap(int &a,int &b)
{
	int temp = a;
	a = b;
	b = temp;

}

//double类型数据交换
void MySwap(double &a, double &b)
{
	double temp = a;
	a = b;
	b = temp;

}
#endif
//模板技术 类型参数化 编写代码可以忽略类型
//为了让编译器区分是普通函数 模板函数

template<class T>	//template<typenme T>
//只对一个函数有效
void MySwap(T &a,T &b)	
{
	T temp = a;
	a = b;
	b = temp;
}

void test()
{
	int a = 10, b = 20;
	//1.自动类型推导
	cout << "a = " << a <<" b = " << b << endl;
	MySwap(a, b);
	cout << "a = " << a << " b = " << b << endl;

	double d1 = 1.2231;
	double d2 = 9.231;

	cout << "d1 = " << d1 << " d2 = " << d2 << endl;
	MySwap(d1, d2);
	cout << "d1 = " << d1 << " d2 = " << d2 << endl;

	//2.显示的指定类型
	MySwap<int>(a, b);
}

int main()
{
	test();
	system("pause");
	return 0;
}

函数模板和普通函数的区别？

  • 函数模板不允许自动类型转化
  • 普通函数能够进行类型转化

函数模板和普通函数在一起调用规则：

  • 函数模板可以被重载
  • C++优先考虑普通函数
  • 如果函数模板产生一个更好的匹配，那么选择模板
#include <iostream>
using namespace std;

template<class T>
int Myadd(T a, T b)
{
	return a + b;
}

int Myadd(int a, char c)
{
	return a + c;
}

void test()
{
	int a = 10;
	int b = 20;
	char c1 = 'a';
	char c2 = 'b';

	//普通函数能够进行类型转化
	cout<< Myadd(a, c1) << endl;

	//函数模板必须严格的类型匹配
	cout<< Myadd(a, b) << endl;

	//普通函数能够进行类型转化
	cout << Myadd(c1, b) << endl;

}

template<class T>
void Print(T a)
{

}

template<class T>
void Print(T a,T b)
{

}

int main()
{
	test();
	system("pause");
	return 0;
}

通过函数模板生成一个模板函数，然后被调用

函数模板—>模板函数—>被调用

函数模板机制：

编译器并不是把函数模板处理成能够处理任何类型的函数

函数模板通过具体类型产生不同的函数

编译器会对函数模板进行两次编译***，在声明的地方对模板本身进行编译，在调用的地方*对参数替换后的代码进行编译

#include <iostream>
using namespace std;

template<class T>
class Person
{
public:
	Person(T id,T age)
	{
		this->m_ID = id;
		this->m_Age = age;
	}
	void show()
	{
		cout << "ID:" << m_ID << " Age:" << m_Age << endl;
	}
public:
	T m_ID;
	T m_Age;

};


void test()
{
	Person<int> p(10,20);
	p.show();
}
int main()
{
	test();
	system("pause");
	return 0;
}

对char类型和int类型数组进行排序

#include <iostream>
using namespace std;

//对char类型和int类型数组进行排序

//打印函数
template<class T>
void PrintArray(T * arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << ' ';
	}
	cout << endl;

}

//排序
template<class T>
void MySort(T *arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				T temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

int main()
{
	//数组
	int arr[] = { 2,6,1,8,9,3};
	//数组长度
	int len = sizeof(arr) / sizeof(arr[0]);

	//排序之前
	cout << "排序之前："<<endl;
	PrintArray(arr, len);
	//排序
	MySort(arr,len);
	//排序之后
	cout << "排序之后："<<endl;
	PrintArray(arr, len);
	
	cout << "------------" << endl;
	char chArr[] = {'c','a','p','b','t'};
	len = sizeof(chArr) / sizeof(chArr[0]);

	//排序之前
	cout << "排序之前：" << endl;
	PrintArray(chArr, len);
	//排序
	MySort(chArr, len);
	//排序之后
	cout << "排序之后：" << endl;
	PrintArray(chArr, len);
	
	system("pause");
	return 0;
}

1.3 类模板派生普通类

template<class T>
class Person
{
public:
	Person()
	{
		m_Age = 0;
	}
public:
	T m_Age;

};

//类区定义对象：这个对象是需要编译"分配内存"
class SubPerson :public Person<int>{};

1.4类模板派生类模板

#include <iostream>
using namespace std;

template<class T>
class Animal
{
public:
	void Shout()
	{
		cout << m_Age << "岁的动物在叫！" << endl;
	}
public:
	T m_Age;
};

template<class T>
class Cat :public Animal<T> {};

int main()
{
	Cat<int> cat;
	return 0;
}

1.5类模板类内实现

#include <iostream>
#include <string>

using namespace std;

//类内实现
template<class T1,class T2>
class Person
{
public:
	Person(T1 name,T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	void Show()
	{
		cout << "Name:" << this->m_Name << " Age:" << this->m_Age << endl;
	}
public:
	T1 m_Name;
	T2 m_Age;
};

void test()
{
	Person<string, int> p("spc",21);
	p.Show();
}
int main()
{
	test();
	system("pause");
	return 0;
}

1.6类模板碰到static成员

  • 从类模板实例化的每一个模板类有自己的类模板数据成员，该模板的所有对象（具体定义出来的对象）共享一个static数据成员

实例化出来的对象共享static关键字，

1.7类型转换

类型转换含义是通过改变一个变量的类型为别的类型从而改变该变量的表示方式。

static_cast（内置数据类型，指针和引用（有继承关系））一般的转换
dynamic_cast通常在基类和派生类之间转换时使用
const_cast主要针对const的转换
reinterpret_cast用于进行没有任何关联之间的转换

类型转换static_cast和dynamic_cast

#include <iostream>
using namespace std;
class Building {};
class Animal {};
class Cat :public Animal {};
//static_cast
void test01()
{
	int a = 65;
	char c = static_cast<char>(a);
	cout << c << endl;


	//转换具有继承关系的指针
	//父类指针转化成子类指针
	Animal * ani = NULL;
	Cat *cat = static_cast<Cat *>(ani);

	//子类指针转化成父类指针
	Cat *soncat = NULL;
	Animal *fani = static_cast<Animal *>(soncat);

	Animal o;
	Animal & ano = o;
	Cat & c = static_cast<Cat &>(ano);

	Cat sc;
	Cat &sco = sc;
	Animal fan = static_cast<Animal &>(sco);

	//static_cast 用于内置的数据类型
	//还有具有继承关系的指针或者引用
}

//dynamic_cast 转换具有继承关系的指针或者引用，转换前会进行对象类型检查
void test02()
{
	Cat *cat = NULL;
	Animal *animal = dynamic_cast<Animal *>(cat);
	
	//子类指针可以转化为父类指针（从大到小），类型安全

}
int main()
{
	test01();
	system("pause");
	return 0;
}

结论：

  1. static_cast 用于内置的数据类型，还有具有继承关系的指针或者引用
  2. dynamic_cast 转换具有继承关系的指针或者引用，转换前会进行对象类型检查 子类指针可以转化为父类指针（从大到小），类型安全

2 STL初识

2.1 STL的诞生

2.2 STL基本概念

  • 标准模板库
  • STL从广义上分为：容器、算法、迭代器
  • 容器和算法之间通过迭代器无缝连接
  • STL所有的代码都采用模板类和模板函数

2.3 STL六大组件

STL六大组件：容器、算法、迭代器、仿函数、适配器、空间配置器

  1. 容器：各种数据结构，用来存数据
  2. 算法：常用算法
  3. 迭代器：容器和算法之间的胶合剂
  4. 仿函数：行为类似的函数
  5. 适配器：用来修饰容器或仿函数或迭代器接口的东西
  6. 空间配置器：负责空间的配合和管理

vector存放内置类型数据

容器：vector

算法：for_each

迭代器：vector<int>::iterator

#include <iostream>
#include <vector>
#include <algorithm> //标准算法的头文件
using namespace std;

//vector容器存放内置数据类型
void myPrint(int val)
{
	cout << val << endl;
}

void test()
{
	//创建了一个vector容器
	vector<int> v;

	//向容器中插入数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);

	/*//通过迭代器访问容器中的数据
	vector<int>::iterator itBegin = v.begin();	//起始迭代器，指向容器中的第一个元素
	vector<int>::iterator itEnd = v.end();	//结束迭代器 指向容器中最后一个元素的下个函数

	//第一种遍历方式
	while (itBegin != itEnd)
	{
		cout << *itBegin << endl;
		itBegin++;
	}

	//第二种遍历方式
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << endl;
	}*/
	
	//第三种遍历方式 利用STL提供的遍历方式
	for_each(v.begin(), v.end(), myPrint);
}


int main()
{
	test();
	system("pause");
	return 0;
}

vector存放自定义数据类型

#include <iostream>
#include <vector>
#include <string>
#include <algorithm> //标准算法的头文件
using namespace std;

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
public:
	string m_Name;
	int m_Age;
};


void test()
{
	vector<Person> v;

	Person p1("a", 10);
	Person p2("b", 11);
	Person p3("c", 12);
	Person p4("d", 13);
	Person p5("e", 14);

	//向容器中添加数据
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);

	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "姓名：" << (*it).m_Name << " 年龄："<<it->m_Age << endl;
	}
} 

void test01()
{
	vector<Person*> v;

	Person p1("a", 10);
	Person p2("b", 11);
	Person p3("c", 12);
	Person p4("d", 13);
	Person p5("e", 14);

	//向容器中添加数据
	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);
	v.push_back(&p5);

	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "::姓名：" << (*it)->m_Name << " 年龄：" << (*it)->m_Age << endl;
	}
}

int main()
{
	test();
	test01();
	system("pause");
	return 0;
}

vector容器嵌套容器

#include <iostream>
#include <vector>
#include <string>
#include <algorithm> //标准算法的头文件
using namespace std;

void test()
{
	vector<vector<int>> v;
	

	//创建小容器
	vector<int> v1;
	vector<int> v2;
	vector<int> v3;
	vector<int> v4;

	//向小容器中添加数据
	for (int i = 0; i < 4; i++)
	{
		v1.push_back(i + 1);
		v2.push_back(i + 2);
		v3.push_back(i + 3);
		v4.push_back(i + 4);
	}

	//将小容器插入到大的容器中
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);

	for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
	{
		// (*it) -----vector<int>容器
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
		{
			cout << *vit << " ";
		}
		cout << endl;
	}
} 

int main()
{
	test();
	system("pause");
	return 0;
}

3.1 string容器

3.1.1 string构造函数

string本质是一个类

构造函数原型：

  • string(); //创建一个空字符串，例如string str;
  • string(const char *s); //使用字符串s初始化
  • string(const string &str); //使用一个string对象初始化另一个string对象
  • string(int n,char c) //使用n个字符c初始化
#include <iostream>
#include <string>
using namespace std;

void test()
{
	string s1;		
	const char *str = "hello world";
	string s2(str);
	cout << "s2:" << s2 <<endl;

	string s3(s2);
	cout << "s3:" << s3 << endl;

	string s4(10, 'a');
	cout << "s4:" << s4 << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

3.1.2string赋值操作

功能描述：

  • 给string字符串进行赋值

赋值的函数原型：

  • string & operator = (const char *s); //char*类型字符串赋值给当前的字符串
  • string & operator = (const string &s); //把字符串s赋值给当前的字符串
  • string & operator = (char c); //字符赋值给当前的字符串
  • string & assign(const char *s); //把字符串s赋给当前的字符串
  • string & assign(const char *s，int n); //把字符串s的当前n个字符赋给当前的字符串
  • string & assign(const string &s); //把字符串s赋给当前的字符串
  • string & assign(int n,char c); //用n个字符c赋给当前字符串
#include <iostream>
#include <string>
using namespace std;

//string赋值操作

/*
* `string & operator = (const char *s);`	//char*类型字符串赋值给当前的字符串
* `string & operator = (const string &s);`	 //把字符串s赋值给当前的字符串
* `string & operator = (char c);`           //字符赋值给当前的字符串
* `string & assign(const char *s);`         //把字符串s赋给当前的字符串
* `string & assign(const char *s，int n);`  //把字符串s的当前n个字符赋给当前的字符串
*  `string & assign(const string &s);`     //把字符串s赋给当前的字符串
* `string & assign(int n,char c);`         //用n个字符c赋给当前字符串
*/

void test()
{
	string str1;
	str1 = "hello world";
	cout << "str1 = " << str1 << endl;

	string str2;
	str2 = str1;
	cout << "str2 = " << str2 << endl;

	string str3;
	str3 = 'a';
	cout << "str3 = " << str3 << endl;

	string str4;
	str4.assign("hello C++");
	cout << "str4 = " << str4 << endl;

	string str5;
	str5.assign("hello C++",5);//输出str5的前五个字符串
	cout << "str5 = " << str5 << endl;

	string str6;
	str6.assign(str4);
	cout << "str6 = " << str6 << endl;

	string str7;
	str7.assign(2,'s');
	cout << "str7 = " << str7 << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

3.1.3string字符串拼接

功能描述：

  • 实现在字符串末尾拼接字符串

函数原型：

  • string & operator+=(const char *str); //重载+=字符串

  • string & operator+=(const char c); //重载+=字符串

  • string & operator+=(const string &str); //重载+=字符串

  • string & append(const char *s); //把字符串s连接到当前字符串结尾

  • string & append(const char *s，int n); //把字符串s前n个字符连接到当前字符串结尾

  • string & append(const string &str); //同operator+=(const string &str)

  • string & append(const string &s,int pos,int n);

​ //字符串s中从pos开始的n个字符串连接到当前字符串的结尾

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

//string赋值操作

/*
* `string & operator+=(const char *str);`		    //重载+=字符串
* `string & operator+=(const char c);`     		     //重载+=字符串
* `string & operator+=(const string &str);`       //重载+=字符串
* `string & append(const char *s);`                       //把字符串s连接到当前字符串结尾
* `string & append(const char *s，int n);`         //把字符串s前n个字符连接到当前字符串结尾
* `string & append(const string &str);`               //同operator+=(const string &str)
* `string & append(const string &s,int pos,int n);`
​       //字符串s中从pos开始的n个字符串连接到当前字符串的结尾
*/

void test()
{
	string str1 = "我";
	str1 += "爱玩游戏";
	cout << "str1 = " << str1 << endl;

	str1 += ':';
	cout << "str1 = " << str1 << endl;

	string str2 = "LOL DNF";
	str1 += str2;
	cout << "str1 = " << str1 << endl;

	string str3 = "I";
	str3.append(" love games");
	cout << "str3 = " << str3 << endl;

	str3.append(":abcdef",3);
	cout << "str3 = " << str3 << endl;

	str3.append(str2);
	cout << "str3 = " << str3 << endl;

	//str3.append(str2,0,3);//直截取LOL
	str3.append(str2,4,3);//直截取DNF
	cout << "str3 = " << str3 << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

3.1.4string查找和替换

功能描述：

  • 查找：查找指定字符串是否存在
  • 替换：在指定的位置替换字符串

函数原型：

  • int find(const string &str,int pos = 0)const; //查找str第一次出现的位置，从pos开始查找

  • int find(const string &str,int pos = 0)const; //查找str最后一次位置，从pos开始查

  • String & replace(int pos,int n,const string & str); //替换从pos开n个字符为字符串str

//字符串的查找和替换

//1.查找
void test()
{
	string str1 = "abcdefpdsde";
	int pos = str1.find("de");	//从0开始索引
	if (pos == -1)
	{
		cout << "未找到字符串" << endl;
	}
	else
	{
		cout << "找到字符串，pos = " << pos << endl;
	}
	//rfind和find区别
	//rfind是从右往左查  find是从左往右查
	pos = str1.rfind("de");
	cout << "pos = " << pos << endl;
}

//2.替换
void test02()
{
	string str2 = "asqwecb";
	str2.replace(1,3,"1111");	//从1号位置起3个字符替换为1111
	cout << "str2 = " << str2 << endl;

}

总结:

  • find是从左往右查，rfind是从右往左查
  • find找到字符串后返回查找的第一个字符位置，找不到返回-1
  • replace在替换时，要指定从哪个位置起，多少个字符，替换成什么样子的字符串

3.1.5 string字符串比较

功能描述：

  • 字符串之间的比较

比较方式：

  • 字符串比较是按字符的ASCII码进行对比

= 返回 0

> 返回 1

< 返回 -1

函数原型：

  • int compare(const string & str)const; //与字符串str比较
  • int compare(const char *str)const; //与字符串str比较
//字符串比较的操作

void test()
{
	string str1 = "aello";
	string str2 = "hello";
	if (str1.compare(str2) == 0)
	{
		cout << "str1 = str2 " << endl;
	}
	else if(str1.compare(str2) == 1)
	{
		cout << "str1 > str2 " << endl;
	}
	else if(str1.compare(str2) == -1)
	{
		cout << "str1 < str2 " << endl;
	}

}

3.1.6string字符存取

string中单个字符存取方式有两种

  • char & operator[](int n); //通过[]方式取字符
  • char & at(int n); //通过at方式获取字符
//字符存取

void test()
{
	string str = "hello";
	//cout << "str = " << str << endl;
	
	//1.通过[]访问单个字符
	for (int i = 0; i < str.size(); i++)
	{
		cout << str[i] << " ";
	}
	cout << endl;
	//2.通过at方式访问单个字符
	for (int i = 0; i < str.size(); i++)
	{
		cout << str.at(i) << " ";
	}
	cout << endl;

	str[0] = 'H';
	str.at(1) = 'E';
	cout << "str = " << str << endl;
}

总结：string字符串中单个字符存取有两种方式，利用[]或at

3.1.7string插入和删除

功能描述：

  • 对string字符串进行插入和删除字符操作

函数原型:

  • string & insert(int pos,const char *str); //插入字符串
  • string & insert(int pos,const string &str); //插入字符串
  • string & insert(int pos,int n,char c); //在指定位置插入n个字符c
  • string & erase(int pos,int n = npos); //删除从pos开始的n个字符
//字符串的插入和删除

void test()
{
	string str = "hello";
	
	//插入
	str.insert(1,"111");
	cout << "str = " << str << endl;

	str.erase(1,3);
	cout << "str = " << str << endl;

}

总结：插入和删除的其实下标都是从0开始

3.1.8 string 子串

功能描述：

  • 从字符串中获取想要的子串

函数原型：

  • string substr(int pos,int n=npos)const; //返回由pos开始的n个字符组成字符串
//string求字串

void test()
{
	string str = "abcdef";
	
	string subStr = str.substr(1, 3);
	
	cout << "subStr = " << subStr << endl;

}

//使用操作
void test02()
{
	string email = "lincspc@126.com";

	//从邮件的地址中获取用户名信息

	int pos = email.find("@");

	cout << "pos = " << pos << endl;

	string usrName = email.substr(0, pos);
	
	cout << "usrName = " << usrName << endl;


}

3.2vector容器

3.2.1 vector基本概念

功能：

  • vector数据结构和数组非常相似，也称为单端数组

vector与普通数组的区别：

  • 不同之处在于数组是静态空间，而vector可以动态扩展

动态扩展：

  • 并不是在原空间之后续新空间，而是找更大的内存空间，然后将原数据拷贝至新空间，释放原空间

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gpw42T2j-1605440543113)(C:\Users\52675\AppData\Roaming\Typora\typora-user-images\1605316527319.png)]

  • vector容器的迭代器是支持随机访问的迭代器

3.2.2vector构造函数

功能描述：

  • 创建vector容器

函数原型：

  • vector<T> v; //采用模板实现类实现，默认构造函数
  • vector(v.begin(),v.end()); //将v**[v.begin(),v.end())**区间中的元素拷贝给本身
  • vector(n,elem); //构造函数将n个elem拷贝给本身
  • vector(const vector &vec); //拷贝构造函数
void printVector(vector<int> &v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	vector<int>  v1;		//默认构造 无参构造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	cout << "v1: ";
	printVector(v1);

	//通过区间的方式来进行构造
	vector<int> v2(v1.begin(), v1.end());
	cout << "v2: ";
	printVector(v2);

	//n个elem方式构造
	vector<int>v3(10, 3);
	cout << "v3: ";
	printVector(v3);

	//拷贝构造
	vector<int> v4(v3);
	cout << "v4: ";
	printVector(v4);
}

3.2.3vector赋值操作

功能描述：

  • 给vector容器进行赋值

函数原型：

  • vector & operator=(const vector &vec); //重载等号操作符

  • assign(beg,end); //将**[beg,end)**区间中的数据拷贝赋值给本身

  • assign(n,elem); //将n个elem拷贝赋值给本身

//vector赋值

void printVector(vector<int> &v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	vector<int> v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	cout << "v1: ";
	printVector(v1);

	//赋值 operator=
	vector<int> v2;
	v2 = v1;
	cout << "v2: ";
	printVector(v2);

	//assign
	vector<int> v3;
	v3.assign(v1.begin(), v1.end());
	cout << "v3: ";
	printVector(v3);

	vector<int> v4;
	v4.assign(10,100);
	cout << "v4: ";
	printVector(v4);
}

3.2.4 vector容量和大小

功能描述：

  • 对vector容器的容量和大小操作

函数原型：

  • empty(); //判断容器是否为空
  • capacity(); //容器的容量
  • size(); //返回容器中元素的个数
  • resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值重新填充新位置。

​ //如果容器变短，则末尾超出容器的长度被删除

  • resize(int num,elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置

​ //如果容器变短，则末尾超出容器的长度被删除

//vector容量和大小

void printVector(vector<int> &v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	vector<int> v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	cout << "v1: ";
	printVector(v1);

	if (v1.empty())		//为真 代表容器为空
	{
		cout << "v1为空" << endl;
	}
	else
	{
		cout << "v1不为空" << endl;
		cout << "v1的容量为：" << v1.capacity() << endl;
		cout << "v1的大小为：" << v1.size() << endl;
	}

	//重新指定大小
	v1.resize(15, 3);	 //利用重载版本，可以指定默认填充值，参数为3
	cout << endl;
	cout << "v1 :";
	printVector(v1);	 //如果重新指定的比原来长了，默认用0填充新的位置

	v1.resize(5);
	cout << "v1 :";
	printVector(v1);	//如果重新指定的比原来短了，超出的部分会删除掉
}

总结：

  • 判断是否为空 — empty
  • 返回元素个数 — size
  • 返回容器容量 — capacity
  • 重新指定大小 — resize

3.2.5vector插入和删除

功能描述：

  • 对vector容器进行插入，删除操作

函数原型：

  • push_back(ele); //尾部插入元素ele
  • pop_back(); //删除最后一个元素
  • insert(const_iterator pos,ele); //迭代器指向位置pos插入元素ele
  • insert(const_iterator pos,int count,ele); //迭代器指向位置pos插入count个元素ele
  • erase(const_iterator pos); //删除迭代器指向的元素
  • erase(const_iterator start,const_iterator end); //删除迭代器从start到end之间的元素
  • clear(); //删除容器中所有元素
//vector插入和删除

void printVector(vector<int> &v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	vector<int> v1;
	//尾插
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);

	//遍历
	cout << "v1: ";
	printVector(v1);

	//尾删
	v1.pop_back();
	cout << "v1: ";
	printVector(v1);

	 //插入	第一个参数是迭代器
	v1.insert(v1.begin(), 100);
	cout << "v1: ";
	printVector(v1);

	v1.insert(v1.end(), 2, 3);
	cout << "v1: ";
	printVector(v1);

	//删除	参数也是迭代器
	v1.erase(v1.begin());
	cout << "v1: ";
	printVector(v1);

	//清空
	//v1.erase(v1.begin(), v1.end());
	v1.clear();
	cout << "v1: ";
	printVector(v1);

}

总结：

  • 尾插 — push_back

  • 尾删 — pop_back

  • 删除 — erase(位置迭代器)

  • 清空 — clear

3.2.5 vector容器-数据存取

功能描述：

  • 对vector中的数据的存取操作

函数原型：

  • at(int idx); //返回索引idx所指的数据
  • operator[]; //返回索引idx所指的数据
  • front(); //返回容器中第一个元素数据
  • back(); //返回容器中最后一个数据元素
//vector数据存取

void test()
{
	vector<int>  v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	//利用[]方式访问数组中的元素
	cout << "v1: ";
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << " ";
	}
	cout << endl;
	cout << "v1: ";
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1.at(i) << " ";
	}
	cout << endl;

	//获取第一个元素
	cout << "第一个元素为：" << v1.front() << endl;

	//获取最后一个元素
	cout << "最后一个元素为：" << v1.back() << endl;
}

3.2.7vector互换容器

功能描述：

  • 实现两个容器内元素进行呼唤

函数原型：

  • swap(vec); //将vec与本身的元素互换
//vector容器呼唤

//1.基本使用

//2.实际用途

void printVector(vector<int> &v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	vector<int> v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	cout << "v1 :";
	printVector(v1);

	vector<int> v2;
	for (int i = 9; i >= 0; i--)
	{
		v2.push_back(i);
	}
	cout << "v2 :";
	printVector(v2);

	cout << "交换后：" << endl;
	v1.swap(v2);
	cout << "v1 :";
	printVector(v1);
	cout << "v2 :";
	printVector(v2);

}

//2.实际用途
//巧用swap可以收缩内存空间
void test01()
{
	vector<int>  v;
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);
	}

	cout << "v的容量为：" << v.capacity() << endl;
	cout << "v的大小为：" << v.size() << endl;

	v.resize(3);		//重新指定大小
	cout << "v的容量为：" << v.capacity() << endl;
	cout << "v的大小为：" << v.size() << endl;

	//巧用swap收缩内存
	vector<int>(v).swap(v);
	cout << "v的容量为：" << v.capacity() << endl;
	cout << "v的大小为：" << v.size() << endl;

	//vector<int>(v); 匿名对象 特点：当前对象为匿名对象，系统会回收内存空间
}

总结：swap可以使两个容器互换，可以达到使用的收缩内存效果

3.2.8vector预留空间

功能描述：

  • 减少vector在动态扩展容量时的扩展次数

函数原型：

  • reserve(int len); //容量预留len个元素长度，预留位置不初始化，元素不可访问
//vector容器 预留空间

void test()
{
	vector<int> v;
	//利用reserve预留空间
	v.reserve(100000);
    
	int num = 0;//统计开辟的次数
	int *p = NULL;
	for (int i = 0; i < 100000; i++)
	{
		
		v.push_back(i);
		if (p != &v[0])
		{
			p = &v[0];
			num++;
		}
	}
	cout << "num = " << num << endl;
}

总结：如果数据量较大，可以一开始利用reserve预留空间

3.3 deque容器

3.3.1 deque容器基本概念

功能：

  • 双端数组，可以对头端进行插入删除操作

deque与vector区别：

  • vector对于头部的插入删除效率低，数据量越大，效率越低
  • deque相对而言，对头部的插入删除速度会比vector快
  • vector访问元素时的速度会比deque快，这和两者内部实现有关

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sOcf6jwW-1605440543116)(C:\Users\52675\AppData\Roaming\Typora\typora-user-images\1605332987340.png)]

deuque内部工作原理：

deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据

中控器维护的时每个缓冲区的地址，使得使用deque时像一片连续的内存空间

  • deque容器的迭代器也是支持随机访问的

3.2.2deque构造函数

功能描述：

  • deque容器构造

函数原型：

  • deque<T> deqT; //默认构造形式
  • deque(beg,end); //构造函数将[beg,end]区间中的元素拷贝给本身
  • deque(n,elem); //构造函数将n个elem拷贝给本身
  • deque(const deque & deq); //拷贝构造函数
//deque 构造函数

void printDeque(const deque<int> &d)
{
	for(deque<int>::const_iterator it = d.begin();it != d.end();it++)
	{
		//*it = 100; 容器中的数据不可以修改
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	deque<int> d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	cout << "d1: ";
	printDeque(d1);

	deque<int> d2(d1.begin(),d1.end());
	cout << "d2: ";
	printDeque(d2);

	deque<int> d3(10, 100);
	cout << "d3: ";
	printDeque(d3);

	deque<int> d4(d3);
	cout << "d4: ";
	printDeque(d4);
}

总结：deque容器和vector容器的构造方式几乎一样，灵活应用即可

3.3.3 deque赋值操作

功能描述：

  • 给deque容器进行赋值

函数原型：

  • deque & operator = (const deque &deq); //重载等号操作符
  • assign(beg,end); //将[beg,end)区间中的数据拷贝赋值给本身
  • assign(n,elem); //将n个elem拷贝赋值给本身
//deque 赋值操作

void printDeque(const deque<int> &d)
{
	for(deque<int>::const_iterator it = d.begin();it != d.end();it++)
	{
		//*it = 100; 容器中的数据不可以修改
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	deque<int>  d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	cout << "d1: ";
	printDeque(d1);

	deque<int> d2;
	d2 = d1;
	cout << "d2: ";
	printDeque(d2);

	deque<int> d3;
	d3.assign(d1.begin(), d1.end());
	cout << "d3: ";
	printDeque(d3);

	deque<int> d4;
	d4.assign(10, 3);
	cout << "d4: ";
	printDeque(d4);

}

3.3.4 deque大小操作

功能描述：

  • 对deque容器的大小进行操作

函数原型：

  • deque.empty(); //判断容器是否为空
  • deque.size(); //返回容器元素的个数
  • deque.resize(num); //重新指定容器的长度为num，则以默认值填充新位置

​ //如果容器变短，则末尾超出容器长度的元素被删除

  • deque.resize(num,elem); //重新指定容器的长度为num，则以elem填充新位置

​ //如果容器变短，则末尾超出容器长度的元素被删除

void printDeque(const deque<int> &d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	deque<int> d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	cout << "d1: ";
	printDeque(d1);

	if (d1.empty())
	{
		cout << "d1为空" << endl;
	}
	else
	{
		cout << "d1不为空" << endl;
		cout << "d1的大小：" << d1.size() << endl;
	}

	//重新指定大小
	d1.resize(15,3);
	cout << "d1: ";
	printDeque(d1);

	d1.resize(5);
	cout << "d1: ";
	printDeque(d1);
}

总结：

  • deque没有容量的概念
  • 判断是否为空 — empty
  • 返回元素个数 — size
  • 重新指定个数 — resize

3.3.5 deque插入和删除

功能描述：

  • 向deque容器中插入和删除数据

函数原型：

两端插入操作：

  • push_back(elem); //在容器尾部添加一个数据
  • push_front(elem); //在容器头部插入一个数据
  • pop_back(); //删除容器最后一个数据
  • pop_front(); //删除容器第一个数据

指定位置操作：

  • insert(pos,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置
  • insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值
  • insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值
  • clear(); //清空容器的所有数据
  • erase(beg,end); //删除[beg,end)区间的数据，返回下一个数据的位置
  • erase(pos); //删除pos位置的数据，发挥下一个数据的位置d
//deque容器插入和删除

//两端操作
void printDeque(const deque<int> &d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	deque<int> d1;

	//尾插
	d1.push_back(10);
	d1.push_back(20);
	
	//头插
	d1.push_front(100);
	d1.push_front(100);

	cout << "d1：";
	printDeque(d1);
}

void test01()
{
	deque<int> d1;
	d1.push_back(10);
	d1.push_back(20);

	d1.push_front(100);
	d1.push_front(100);

	cout << "d1：";
	printDeque(d1);

	//insert插入
	d1.insert(d1.begin(),333);
	d1.insert(d1.end(),3,110);
	cout << "d1：";
	printDeque(d1);

	//按照区间来插入
	deque<int> d2;
	d2.push_back(1);
	d2.push_back(2);
	d2.push_back(3);

	d1.insert(d1.begin(), d2.begin(), d2.end());
	cout << "d1：";
	printDeque(d1);
}

void test02()
{
	deque<int> d1;
	//尾插
	d1.push_back(10);
	d1.push_back(20);

	//头插
	d1.push_front(100);
	d1.push_front(200);
	
	deque<int>::iterator it = d1.begin();
	it++;
	d1.erase(d1.begin());
	cout << "d1：";
	printDeque(d1);

	d1.erase(d1.begin(), d1.end());
	cout << "d1：";
	printDeque(d1);
}

总结：

  • 插入和删除提供的位置是迭代器
  • 尾插 — push_back
  • 尾删 — pop_back
  • 头插 — push_front
  • 头删 — pop_front

3.3.6deque数据存取

功能描述：

  • 对deque中的数据的存取操作

函数原型：

  • at(int idx); //返回索引idx所指的数据
  • operator[]; //返回索引idx所指的数据
  • front(); //返回容器中第一个元素数据
  • back(); //返回容器中最后一个数据元素
void test()
{
	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_back(30);
	d.push_front(100);
	d.push_front(200);
	d.push_front(300);

	//通过[]方式访问元素
	for (int i = 0; i < d.size(); i++)
	{
		cout << d[i] << " ";
	}
	cout << endl;
	for (int i = 0; i < d.size(); i++)
	{
		cout << d.at(i) << " ";
	}
	cout << endl;

	cout << "第一个元素为：" << d.front() << endl;
	cout << "最后一个元素为：" << d.back() << endl;
}

总结：

  • 除了用迭代器获取deque容器中元素，[]和at也可以
  • front返回容器第一个元素
  • back返回容器最后一个元素

3.3.7 deque排序

功能描述：

  • 利用算法实现对deque容器进行排序

算法：

  • sort(iterator beg,iterator end); //对beg和end区间内元素进行排序
//deque容器排序
void printDeque(const deque<int> &d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;

}
void test()
{
	deque<int> d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_back(30);
	d1.push_front(100);
	d1.push_front(200);
	d1.push_front(300);

	cout << "排序前d1: ";
	printDeque(d1);
	
	//排序	默认排序规则 从小到大 升序
    //对于支持随机访问的迭代器的容器，都可以利用sort算法直接进行排序
    //vector容器也可以利用sort进行排序
	sort(d1.begin(),d1.end());
	cout << "排序后d1: ";
	printDeque(d1);

}

总结：sort算法非常实用，使用时包含头文件algorithm即可

3.4 stack容器

3.4.1stack基本概念

概念：stack是一种先进后出的数据结构，它是只有一个出口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UUfI0C1d-1605440543118)(C:\Users\52675\AppData\Roaming\Typora\typora-user-images\1605340153176.png)]

栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为

栈中进入数据称为 — 入栈push

栈中弹出数据称为 — 出栈pop

3.4.2 stack常用接口

功能描述：栈容器常用的对外接口

构造函数：

  • stack<T> stk; //stack采用模板类实现，stack对象的默认构造形式
  • stack(const stack &stk); //拷贝构造函数

赋值操作：

  • stack & operator = (const stack &stk); //重载等号操作符

数据存取：

  • push(elem); //向栈顶添加元素
  • pop(); //从栈顶移除第一个元素
  • top(); //返回栈顶元素

大小操作：

  • empty(); //判断栈是否为空
  • size(); //返回栈的大小
void test()
{
	stack<int> s;

	//入栈
	s.push(10);
	s.push(20);
	s.push(30);
	s.push(40);
	cout << "栈的大小" << s.size() << endl;


	//只要栈不为空，查看栈顶，并且执行出栈操作
	while (!s.empty())
	{
		//查看栈顶元素
		cout << "栈顶元素为：" << s.top()<<endl;

		//出栈
		s.pop();
	}
	cout << "栈的大小" << s.size() << endl;

}

总结：

  • 入栈 — push
  • 出栈 — pop
  • 返回栈顶 — top
  • 判断栈是否为空 — empty
  • 返回栈大小 — size

3.5 queue容器

3.5.1 queue基本概念

概念：Queue是一种先进先出的数据结构，它有两个出口

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D4UFQHyF-1605440543121)(C:\Users\52675\AppData\Roaming\Typora\typora-user-images\1605343382452.png)]

队列容器允许从一端新增元素，从另一端移除元素

队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为

队列中进数据称为 — 入队push

队列中出数据称为 — 出队pop

3.5.2 queue常用接口

功能描述：队列容器常用的对外接口

构造函数：

  • queue<T> que; //queue采用模板类实现，queue对象的默认构造形式
  • queue(const que &que);` //拷贝构造函数

赋值操作：

  • queue & operator = (const queue &que);` //重载等号操作符

数据存取：

  • push(elem); //向队尾3添加元素
  • pop(); //从队头移除第一个元素
  • back(); //返回最后一个元素
  • front(); //返回第一个元素

大小操作：

  • empty(); //判断队列是否为空
  • size(); //返回队列的大小
//队列 Queue
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
public:
	string m_Name;
	int m_Age;

};

void test()
{
	queue<Person> q;

	Person p1("唐僧",30);
	Person p2("孙悟空", 1000);
	Person p3("猪八戒", 900);
	Person p4("沙僧",800);

	//入队
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);

	cout << "队列的大小：" << q.size() << endl;
	//判断只要队列不为空，查看对头，查看队尾，出队
	while (!q.empty())
	{
		//查看队头
		cout << "队头元素 ---姓名：" << q.front().m_Name << " 年龄：" << q.front().m_Age << endl;
	
		//查看队尾
		cout << "队尾元素 ---姓名：" << q.back().m_Name << " 年龄：" << q.back().m_Age << endl;

		//出队
		q.pop();
	}
	cout << "队列大小为：" << q.size() << endl;

}

总结：

  • 入队 — push
  • 出队 — pop
  • 返回队头元素 — front
  • 返回队尾元素 — back
  • 判断队列是否为空 — empty
  • 返回队列大小 — size

3.6 list容器

3.6.1 list基本概念

**功能：**将数据进行链式存储

链表时一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链表实现的

链表的组成：链表由一系列结点组成

结点的组成：一个存储数据元素的数据域，另一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YIBq9wIT-1605440543124)(C:\Users\52675\AppData\Roaming\Typora\typora-user-images\image-20201115091644890.png)]

数据域维护的是数据，指针域是维护下一个结点的位置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YNhCRTPN-1605440543125)(C:\Users\52675\AppData\Roaming\Typora\typora-user-images\image-20201115094433728.png)]

由于链表的存储方式并不是连续的空间，因此链表list中的迭代器只能支持前移和后移，属于双向迭代器

list优点：

  • 采用动态存储分配，不会造成内存浪费和溢出

  • 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

list缺点：

  • 链表灵活，但空间（指针域）和时间（遍历）额外耗费比较大

list有一个重要性质，插入操作和删除操作不会造成原有list迭代器的失效

3.6.2 list构造函数

功能描述：

  • 创建list容器

函数原型：

  • list<T> lst; //list采用模板类实现，对象的默认构造形式
  • list(beg,end); //构造函数将[beg,end)区间中的元素拷贝给本身
  • list(n,elem); //构造函数将n个elem拷贝给自身
  • list(const list &lst); //拷贝构造函数
//list容器构造函数
void printList(const list<int> &L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	//创建List容器
	list<int> L1;		//默认构造方式

	//添加数据
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	//遍历容器
	cout << "L1: ";
	printList(L1);

	//区间构造方式
	list<int> L2(L1.begin(), L1.end());
	cout << "L2: ";
	printList(L2);

	//拷贝构造
	list<int> L3(L1);
	cout << "L3: ";
	printList(L3);

	list<int> L4(10,3);
	cout << "L4: ";
	printList(L4);
}

3.6.3 list赋值和交换

功能描述：

  • 给list容器进行赋值，以及交换list容器

函数原型：

  • assign(beg,end); //将[beg,end)区间中的数据拷贝赋值给本身
  • assign(n,elem); //将n个elem拷贝赋值给本身
  • list &operator=(const list &str); //重载等号操作符
  • swap(lst); //将list与本身的元素互换
//list容器的赋值和交换
void printList(const list<int> &L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	list<int> L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	cout << "L1: ";
	printList(L1);

	list<int> L2;
	L2 = L1; //operator=赋值
	cout << "L2: ";
	printList(L2);

	list<int> L3;
	L3.assign(L2.begin(), L2.end());
	cout << "L3: ";
	printList(L3);

	list<int> L4;
	L4.assign(10,3);
	cout << "L4: ";
	printList(L4);
}

void test01()
{
	list<int> L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	cout << "交换前:" << endl;
	cout << "L1: ";
	printList(L1);

	list<int> L2;
	L2.assign(10,3);
	cout << "L2: ";
	printList(L2);

	L1.swap(L2);
	cout << "交换后:" << endl;
	cout << "L1: ";
	printList(L1);
	cout << "L2: ";
	printList(L2);

}

3.6.4 list大小操作

功能描述：

  • 对list容器的大小进行操作

函数原型：

  • empty(); //判断容器是否为空
  • size(); //返回容器中元素的个数
  • resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值重新填充新位置。

​ //如果容器变短，则末尾超出容器的长度被删除

  • resize(int num,elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置

​ //如果容器变短，则末尾超出容器的长度被删除

//list容器大小操作
void printList(const list<int> &L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	list<int> L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	if (!L1.empty())
	{
		cout << "List容器不为空!" << endl;

		cout << "L1: ";
		printList(L1);

		cout << "L1的元素个数为：" << L1.size() << endl;
	}
	else
	{
		cout << "List容器为空!" << endl;
	}

	//重新指定大小
	L1.resize(10,3);
	cout << "L1: ";
	printList(L1);
}

3.6.5 list插入和删除

功能描述：

  • 对list容器进行数据的插入和删除

函数原型：

  • push_push(); //在容器尾部加入一个元素
  • pop_push();//删除容器中最后一个元素
  • push_front(elem); //在容器开头插入一个元素
  • pop_front();//在容器开头移除第一个元素
  • insert(pos,elem);//在pos位置插入elem元素的拷贝，返回新数据的位置
  • insert(pos,n,elem);//在pos位置插入n个elem数据，返回新数据的位置
  • clear();//移除容器的所有数据
  • erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置
  • erase(pos);//删除pos位置的数据，返回下一个数据的位置
  • remove(elem);//删除容器中所有与elem值匹配的元素
//list插入和删除
void printList(const list<int> &L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	list<int> L1;
	//尾插
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	//头插
	L1.push_front(100);
	L1.push_front(200);
	L1.push_front(300);

	//300 200 100 10 20 30 
	cout << "L1: ";
	printList(L1);

	//尾删
	L1.pop_back();
	L1.pop_front();

	//200 100 10 20 
	cout << "L1: ";
	printList(L1);

	//insert插入
	list<int>::iterator it = L1.begin();
	L1.insert(++it, 10000);
	cout << "L1: ";
	printList(L1);

	//删除
	it = L1.begin();
	L1.erase(++it);
	cout << "L1: ";
	printList(L1);

	//移除
	L1.push_back(100000);
	L1.push_back(100000);
	L1.push_back(100000);
	L1.push_back(100000);

	cout << "L1: ";
	printList(L1);
	L1.remove(100000);

	cout << "L1: ";
	printList(L1);

	//清空
	L1.clear();
	cout << "L1: ";
	printList(L1);
}

3.6.6 list数据存取

功能描述：

  • 对list容器中数据进行存取

函数原型：

  • front(); //返回第一个元素
  • back(); //返回最后一个元素
//list容器中的数据存取

void test()
{
	list<int> L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	//L1[0]不可以用[]访问list容器中的元素

	//L1.at(0)不可以用at方式访问list容器中的元素

	//list本质是链表，不是用连续线性空间存储数据，迭代器也是不支持随机访问

	cout<<"第一个元素为："<<L1.front()<<endl;
	cout << "第二个元素为：" << L1.back()<< endl;

	//验证迭代器是不支持随机访问的
	list<int>::iterator it = L1.begin();
	it++;//支持双向（++ --）
	//it = it + 3;
	cout << *it << endl;

}

总结：

  • list容器中不可以通过at或者[]方式访问数据
  • 返回第一个元素 — front
  • 返回最后一个元素 — back

3.6.7 list反转和排序

功能描述：

  • 将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

  • reverse(); //反转链表
  • sort(); //链表排序
//list容器中的反转和排序
void printList(const list<int> &L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;

}

void test()
{
	//反转
	list<int> L1;
	L1.push_back(20);
	L1.push_back(10);
	L1.push_back(50);
	L1.push_back(40);
	L1.push_back(30);

	cout << "反转前：";
	printList(L1);

	//反转后
	cout << "反转后：";
	L1.reverse();
	printList(L1);
}

bool myCompare(int v1,int v2)
{
	//降序 就让第一个数大于第二个数
	return v1 > v2;
}

//排序
void test01()
{
	list<int> L1;
	L1.push_back(20);
	L1.push_back(10);
	L1.push_back(50);
	L1.push_back(40);
	L1.push_back(30);

	cout << "排序前：";
	printList(L1);

	L1.sort();	//默认排序规则 从小到大 升序
	cout << "升序排序后：";
	printList(L1);

	L1.sort(myCompare);	//从大到小 降序
	cout << "降序排序后：";
	printList(L1);
}

总结：

  • 反转 — reverse
  • 排序 — sort(成员函数)

3.7.8排序案例

排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序

class Person
{
public:
	Person(string name, int age, int height,int weight)
	{
		this->m_Name = name;
		this->m_Age = age;
		this->m_Height = height;
		this->m_Weight = weight;
	}

public:
	string m_Name;
	int m_Height;
	int m_Age;
	int m_Weight;
};

void printList(const list<Person> &L)
{
	for (list<Person>::const_iterator it = L.begin(); it != L.end(); it++)
	{ 
		cout << "姓名： " << (*it).m_Name << " 年龄： " << (*it).m_Age << " 身高： "<<(*it).m_Height <<" 体重： "<<(*it).m_Weight<< endl;
	}
}

//指定排序规则
bool comparePerson(Person &p1,Person &p2)
{
	//按照年龄 升序
	if (p1.m_Age == p2.m_Age)
	{
		
		if (p1.m_Height == p2.m_Height)
		{
			//年龄 身高相同 按照体重作为升序
			return p1.m_Weight < p2.m_Weight;
		}
		else
		{
			//年龄相同 按照身高作为降序
			return p1.m_Height > p2.m_Height;
		}	
	}
	else
	{
		return p1.m_Age < p2.m_Age;
	}


}

void test()
{
	list<Person> L;

	Person p1("刘备", 35, 175,150);
	Person p2("曹操", 45, 180,160);
	Person p3("孙权", 40, 170,150);
	Person p4("赵云", 25, 190,140);
	Person p5("张飞", 35, 175,160);
	Person p6("关羽", 35, 200,160);

	L.push_back(p1);
	L.push_back(p2);
	L.push_back(p3);
	L.push_back(p4);
	L.push_back(p5);
	L.push_back(p6);

	cout << "排序前:" << endl;
	printList(L);
	cout << "-------------------------------------" << endl;

	L.sort(comparePerson);
	cout << "排序后:" << endl;
	printList(L);

}

3.7 set/multiset容器

3.7.1 set基本概念

简介：

  • 所有元素都会在插入时自动被排序

本质：

  • set/multiset属于关联式容器，底层结构是用二叉树实现

set和multiset区别：

  • set不允许容器中有重复的元素
  • multiset允许容器中有重复的元素

3.7.2set构造和赋值

构造函数：

  • set<T> st; //默认构造函数
  • set(const set &st); //拷贝构造函数

赋值操作：

  • set & operator = (const set &st); //重载等号操作符
//set容器构造和赋值
void printSet(const set<int> &s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	set<int> s1;
	
	//插入数据 只有insert方式
	s1.insert(10);
	s1.insert(40);
	s1.insert(30);
	s1.insert(20);

	//遍历容器
	//set容器特点：所有元素插入时自动被排序
	//set容器不允许插入重复的值
	printSet(s1);

	set<int> s2(s1);
	printSet(s2);

	set<int> s3;
	s3 = s2;
	printSet(s3);
}

总结：

  • set容器插入数据时用insert
  • set容器插入的数据会自动排序

3.7.3 set大小和交换

**

3.7.4 set插入和删除

功能描述：

  • set容器进行插入数据和删除数据

函数原型：

  • insert(elem);//在容器中插入元素
  • clear();//移除容器的所有数据
  • erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置
  • erase(pos);//删除pos位置的数据，返回下一个数据的位置
  • erase(elem);//删除容器中为elem的元素
//set容器的插入和删除
void printSet(const set<int> &s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	set<int> s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);

	cout << "删除前：" << endl;
	cout << "s1: ";
	printSet(s1);

	cout << "删除后：" << endl;
	s1.erase(s1.begin());
	cout << "s1: ";
	printSet(s1);

	s1.erase(30);
	cout << "s1: ";
	printSet(s1);

	cout << "清空：" << endl;
	s1.clear();
//1.erase(s1.begin(), s1.end());
	cout << "s1: ";
	printSet(s1);
}

3.7.5 查找和统计

功能描述：

  • 对set容器进行查找数据以及统计数据

函数原型：

  • find(key); //查找key是否存在。若存在，返回该键的元素的迭代器，若不存在，返回set.end();
  • count(key); //统计key的元素个数
//set容器 查找和统计

void printSet(const set<int> &s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	//查找
	set<int> s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);

	set<int>::iterator pos = s1.find(323120);
	if (pos != s1.end())
	{
		cout << "找到该元素：" << *pos << endl;
	}
	else
	{
		cout << "未找到元素！" << endl;
	}
}

void test02()
{
	set<int> s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);

	//统计30的个数
	int num = s1.count(30);
	//对于set而言 统计结果 要么是0 要么是1
	cout << "num = " << num << endl;
}

总结：

  • 查找 — （返回的是迭代器）
  • 统计 — （对于set，结果为0或者1）

3.7.6 set和multiset区别

区别：

  • set不可以插入重复数据，而multiset可以
  • set插入数据的同时会返回插入结果，表示插入是否成功
  • multiset不会检测数据，因此可以插入重复数据
void test()
{
	set<int> s1;
	pair <set<int>::iterator, bool> ret = s1.insert(10);

	if (ret.second)
	{
		cout << "第一次插入成功" << endl;
	}
	else
	{
		cout << "第一次插入失败" << endl;
	}
	ret = s1.insert(10);
	if (ret.second)
	{
		cout << "第二次插入成功" << endl;
	}
	else
	{
		cout << "第二次插入失败" << endl;
	}
	
	multiset<int> s2;
	s2.insert(10);
	s2.insert(10);

	for (multiset<int>::iterator it = s2.begin(); it != s2.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

3.7.7 pair对组创建

功能描述：

  • 成对出现的数据，利用对组可以返回两个数据

两种创建方式：

  • pair<type,type> p (value1,value2);
  • pair<type,type> p = make_pair(value1,value2);
//pair对组的创建
void test()
{
	//第一种方式
	pair<string, int> p("Spc", 21);

	cout << "姓名：" << p.first << " 年龄：" << p.second << endl;

	//第二种方式
	pair<string, int> p2 = make_pair("Jk",20);
	cout << "姓名：" << p2.first << " 年龄：" << p2.second << endl;
}

3.7.8 set容器排序

  • set容器默认排序规则为从小到大
  • 利用仿函数，可以改变排序规则

示例一set存放内置数据类型

class MyCompare
{
public:
	bool operator()(int v1,int v2)
	{
		return v1 > v2;
	}

};

void test()
{
	set<int> s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(50);
	s1.insert(40);

	for (set<int>::iterator it = s1.begin(); it != s1.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;

	//指定排序规则为从大到小
	set<int, MyCompare> s2;
	s2.insert(10);
	s2.insert(20);
	s2.insert(30);
	s2.insert(50);
	s2.insert(40);

	for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

总结：利用仿函数可以指定set容器的排序规则

示例二set存放自定义数据类型

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
public:
	string m_Name;
	int m_Age;
};

class MyCompare
{
public:
	bool operator()(const Person &p1,const Person &p2)
	{
		//按照年龄降序
		return p1.m_Age > p2.m_Age;
	}
};

void test()
{
	//自定义数据类型 都会指定排序规则 
	set<Person,MyCompare> s1;

	//创建Person对象
	Person p1("刘备", 24);
	Person p2("关羽", 28);
	Person p3("张飞", 25);
	Person p4("赵云", 21);

	s1.insert(p1);
	s1.insert(p2);
	s1.insert(p3);
	s1.insert(p4);

	for (set<Person, MyCompare>::iterator it = s1.begin(); it != s1.end(); it++)
	{
		cout << "姓名：" << (*it).m_Name << " 年龄：" << (*it).m_Age << endl;
	}
}

总结：

对于自定义数据类型，set容器必须指定排序规则才可以插入数据

3.8 map/multimap容器

3.8.1 map基本概念

简介：

  • map中所有元素都是pair

  • pair中第一个元素为key（键值），起到索引作用，第二个元素为value(实值)

  • 所有元素都会根据元素的键值自动排序

本质：

  • map/multimap属于关联式容器,底层结构是用二叉树实现。

优点：

  • 可以根据key值快速找到value值

map和multimap区别：

  • map不允许容器中有重复key值元素
  • multimap允许容器中有重复key值元素

3.8.2 map构造和赋值

功能描述：

  • 对map容器进行构造和赋值操作

函数原型：

构造：

  • map<T1,T2> mp; //map默认构造函数
  • map(const map &map); //拷贝构造函数

赋值：

  • map & operator=(const map &mp); //重载等号操作夫
//map容器 构造和赋值

void printMap(map<int,int> &m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << (*it).first << " value = " << it->second << endl;
	}
	cout << endl;
}
void test()
{
	//创建map容器
	map<int, int> m;

	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(4, 40));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));

	printMap(m);
	
	//拷贝构造
	map<int, int> m1(m);
	printMap(m1);

	//赋值
	map<int, int> m2;
	m2 = m1;
	printMap(m2);
}

总结：map中所有元素都是成对出现，插入数据时要使用对组

3.8.3 map大小和交换

功能描述：

  • 统计set容器大小以及交换set容器

函数原型：

  • empty(); //判断容器是否为空
  • size(); //返回容器中元素的个数
  • swap(st); //交换两个集合容器
// map容器 大小和交换

void printMap(const map<int, int> &m)
{
	for (map<int, int>::const_iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;

}

void test()
{
	map<int, int> m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));

	if (m.empty())
	{
		cout << "m为空" << endl;
	}
	else
	{
		cout << "m不为空" << endl;
		cout << "map的大小为：" << m.size() << endl;
	}

}

//交换
void test01()
{
	map<int, int> m1;
	m1.insert(pair<int, int>(1, 10));
	m1.insert(pair<int, int>(2, 20));
	m1.insert(pair<int, int>(3, 30));

	map<int, int> m2;
	m2.insert(pair<int, int>(4, 100));
	m2.insert(pair<int, int>(5, 200));
	m2.insert(pair<int, int>(6, 300));

	cout << "交换前：" << endl;;
	cout << "m1: " << endl;
	printMap(m1);
	cout << "m2: " << endl;
	printMap(m2);
	
	m2.swap(m1);

	cout << "交换后："<<endl;
	cout << "m1: " << endl;
	printMap(m1);
	cout << "m2: " << endl;
	printMap(m2);
}

3.8.4 map插入和删除

功能描述：

  • 对map容器进行插入数据和删除数据

函数原型：

  • insert(elem);//在容器中插入元素
  • clear();//移除容器的所有数据
  • erase(beg,end);//删除[beg,end)区间的数据，返回下一个元素的迭代器
  • erase(pos);//删除pos位置的数据，返回下一个元素的迭代器
  • erase(key);//删除容器中值为key的元素
// map容器插入和删除
void printMap(const map<int, int> &m)
{
	for (map<int, int>::const_iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;
}

void test()
{
	map<int, int> m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));

	m.insert(make_pair(4, 40));

	m.insert(map<int,int>::value_type(5,50));

	m[6] = 60;
	printMap(m);

	//删除
	m.erase(m.begin());
	printMap(m);

	m.erase(3);	//按照key删除
	printMap(m);

	m.erase(m.begin(),m.end());
	printMap(m);

	m.clear();
	printMap(m);
}

3.8.5 map查找和统计

功能描述：

  • 对map容器进行查找数据以及统计数据

函数原型：

  • find(key); //查找key是否存在。若存在，返回该键的元素的迭代器，若不存在，返回map.end();
  • count(key); //统计key的元素个数
// map容器 查找和统计
void printMap(const map<int, int> &m)
{
	for (map<int, int>::const_iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;
}

void test()
{
	map<int, int> m;
	
	m.insert(make_pair(1, 10));
	m.insert(make_pair(2, 10));
	m.insert(make_pair(3, 10));

	cout << "m:" << endl;
	printMap(m);

	map<int,int>::iterator pos = m.find(3);
	if (pos != m.end())
	{
		cout << "查到了元素 key = " << (*pos).first << " value = " << pos->second << endl;
	}
	else
	{
		cout << "未找到该元素" << endl;
	}

	//统计
    //map不允许插入重复key元素,count统计而言 结果要么是0 要么是1
    //multimp的count统计可能大于1
	int num = m.count(4);
	cout << "num = " << num << endl;


}

3.8.6 map容器排序

  • 利用仿函数，可以改变排序规则
class MyCompare
{
public:
	bool operator()(int v1,int v2)
	{
		//降序
		return v1>v2;
	}
};

//map容器中的排序
void test()
{
	map<int, int,MyCompare> m;
	m.insert(make_pair(1, 10));
	m.insert(make_pair(2, 20));
	m.insert(make_pair(3, 30));
	m.insert(make_pair(4, 40));
	m.insert(make_pair(5, 50));

	for (map<int, int,MyCompare::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << it->first << " value = " << it->second << endl;
	}

}

总结：

  • 利用仿函数可以指定map容器的排序规则
  • 对于自定义数据类型，map必须要指定排序规则，同set容器
热心网友小邵
关注
专栏目录
数据结构之队列的基本操作入队出队初始化删除-c++代码实现及运行实例结果
IT_job的博客
12-19 2173
C++的头文件已经包含了队列如下所示，但我们也要了解一下他们的实现原理，而且stl提供的容器都是“通用版本”，在解决某些具体问题时，stl不一定是最合适最高效的，有时候还是要自己实现特化版本……，所以自己编写一次代码 直接调用头文件方法 代码如下： #include #include//头文件 using namespace std; int main() { queue
关于队列的入队，出队，遍历操作
qq_45662882的博客
09-24 1307
**队列的操作** #include<stdio.h> #include<malloc.h> #define MAXQSIZE 10 typedef struct { int *base; int front; int rear; }SqQueue; void InitQueue(SqQueu...
STL
庸人自扰
03-06 107
STL从广义上分为 容器 算法 迭代器 和算法之间通过迭代器进行无缝连接 容器中可以嵌套容器 容器分为序列式容器和关联式容器 迭代器可以理解为是用来遍历容器的指针，默认指向第一个位置，事实上，迭代器是一个类，这个类封装了一个指针 迭代器相当于算法与容器之间的桥梁，给算法传入迭代器 // 容器迭代器分离实现.cpp: 定义控制台应用程序的入口点。 // #include "stdafx.h" #i...
队列的创建，销毁，清空，入队，出队，判空，判满等操作
08-17
本程序实现了队列的相关操作，包括 创建，销毁，清空，入队，出队，判空，判满等操作，实现过程清晰简洁。是很好的学习资源
C++ stl队列Queue用法介绍:删除，插入等操作代码举例
yuzeze的专栏
06-13 1万+
C++队列queue模板类的定义在头文件中,queue 模板类需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque 类型。 C++队列Queue是一种容器适配器，它...     C++队列queue模板类的定义在头文件中,queue 模板类需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque
C++ STL容器在实际项目中的选择和使用策略
最新发布
AntonioMargery的博客
04-20 792
通过合理地选择和使用STL容器，我们可以提高代码的效率、可读性和可维护性，从而构建出更加健壮和高效的C++应用程序。在C++编程中，标准模板库（STL）提供了丰富的容器类，这些容器类为数据的存储和操作提供了高效且灵活的方式。在这个案例中，我们使用了map容器的插入、查找、删除和遍历等操作，实现了对学生信息的存储和管理。我们可以选择使用map作为存储学生信息的容器，因为map可以根据学生的ID快速查找、插入和删除学生信息。C++ STL中的容器大致可分为三类：序列容器、关联容器和容器适配器。
C++ STL容器之heap（堆）篇
Flowing_River的博客
08-12 2995
没有想到第一次用堆 是在LeetCode的算法题上，作为一个学生党来说，需要用到堆跟堆算法的场景确实比较少。 这篇文章不仅是跟大家分享有关于堆的知识，也是为了通过这种方式巩固我自己对堆的理解。并且我将通过最开始说的拿到LeetCode题来跟大家一起实践堆的使用 。 本期文章代码将用C++来进行说明。
C++ STL容器stack和queue详解
09-01
C++ STL（Standard Template Library，标准模板库）提供了两种特殊的线性容器：stack（栈）和queue（队列），它们都是基于顺序容器（如vector或deque）实现的抽象数据类型，用于实现特定的数据操作逻辑。 **1. ...
实践案例-基于STL的演讲比赛流程管理系统_alivearr_c++STL容器的使用_随机分组_
09-28
综上所述，这个实践案例展示了C++ STL容器在实际项目中的应用，包括数据存储、操作和算法的实现。通过合理选择和组合不同的容器，可以有效地解决问题，提高代码的可读性和可维护性。在深入学习和熟练掌握STL后，...
c++STL容器讲义与演示
01-25
总结，C++ STL容器是强大且灵活的工具，为程序员提供了高效的数据管理方案。理解每个容器的特点，选择合适的容器，并熟练运用迭代器、算法和函数对象，能够写出更加高效、简洁的C++代码。学习和掌握STL，对于提升C++...
C++进阶与拔高（十）（C++ STL）（vector，list，stack和queue接口操作）
Lao_tan的博客
07-30 1603
第五章 STL 容器的具体用法 5.1 vector用法总结 5.1.1 介绍        vector可以用来表示一个不定长度的数组，它是一种序列容器。就像数组一样，vector也采用连续的存储空间来存储元素，其中重载了下标操作符“[ ]”，可以对vector元素进行访问。与数组不同的是它的大小是可以动态改变的。当新元素插入容器时，vector不会每次都重新分配大小。与其他动态序列容器相...
c++实现队列操作（建对、入队、出对）
智慧源
06-25 1690
<br />template<class T> class Node/*定义节点的头文件，文件名为:b.h */ { public: int data; Node<T> *next; Node() { this->next=NULL; } Node(int data,Node<T> *next=NULL) { this->data=data; this->next=next; } }; #include<iostream.h> #incl
C++ STL库史上最详细的教程
qq_43147508的博客
12-29 3641
C++ STL库使用
C++ 清空队列(queue)的几种方法
weixin_30364325的博客
09-15 2674
C++中的queue自身是不支持clear操作的，但是双端队列deque是支持clear操作的。 方法一 直接用空的队列对象赋值 queue<int> q1; // process // ... q1 = queue<int>(); 方法二 遍历出队列 while (!Q.empty()) Q.pop(); 方法三 使用swap，这种是最高效的，定义clear...
c++实现队列基本操作
weixin_44046152的博客
11-26 4920
c++实现队列基本操作，进队，出队，遍历队列 2019-11-26 #include <iostream> using namespace std; typedef int DataType; #define Node ElemType class Node { public: DataType data; ElemType *next; }; class QueueLink...
C++ STL list的初始化、添加、遍历、插入、删除、查找、排序、释放
热门推荐
烟花易冷
08-20 16万+
list是C++标准模版库(STL,Standard Template Library)中的部分内容。实际上,list容器就是一个双向链表,可以高效地进行插入删除元素。 使用list容器之前必须加上STL的list容器的头文件：#include; list属于std命名域的内容，因此需要通过命名限定：using std::list;也可以直接使用全局的命名空间方式：using nam
C++ STL容器之可变长度 数组vector
xinlongkun的博客
11-24 954
C++STL容器总结
-_-
02-27 8万+
持续更新中！！！ 各大容器的特点： 1.可以用下标访问的容器有（既可以插入也可以赋值）：vector、deque、map； 特别要注意一下，vector和deque如果没有预先指定大小，是不能用下标法插入元素的...
C++ STL之List实现
Juicewyh的博客
09-25 8895
概述     List是STL中常用的容器之一，List将元素按顺序储存到链表中，在快速删除和快速插入方面比vector高出许多。STL中的list是一双向链表，具有指向前一节点和后一节点的指针。那么我们开始写一个属于自己的List吧。 list的节点     list的节点应由指向前一节点的指针，指向后一节点的指针一节储存的元素构成。那么我给出节点的定义 template &lt;ty...
C++ STL容器操作大全
C++STL操作大全 C++ STL（Standard Template Library）是C++标准库中的一个组件，提供了大量的泛型容器、算法和迭代器，帮助开发者快速构建高效、可靠的应用程序。下面是C++ STL中的一些重要知识点： 一、Vector ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值