STL——string、vector、deque容器

news2025/2/1 2:00:33

初识STL

    • **STL的基本概念**
    • **vector容器存放内置数据类型**
    • **vector容器中存放自定义数据类型**
    • **vector容器嵌套vector容器**
    • **string容器——构造函数**
    • **string容器——赋值操作**
    • **string容器——字符串拼接**
    • **string容器——字符串的查找和替换**
    • **string容器——字符串比较**
    • **string容器——字符存取**
    • **string容器——字符串的插入和删除**
    • **string容器——字串获取**
    • **vector容器——构造函数**
    • **vector容器——赋值操作**
    • **vector容器——容量和大小**
    • **vector容器——插入和删除**
    • **vector容器——数据存取**
    • **vector容器——互换容器**
    • **vector容器——预留空间**
    • **deque容器——构造函数**
    • **deque容器——赋值操作**
    • **deque容器——大小操作**
    • **deque容器——插入和删除**
    • **deque容器——数据存储**
    • **deque容器——排序操作**

STL的基本概念

STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器(配接器)、空间配置器
1.容器:各种数据结构，如vector、list、deque、set、map等,用来存放数据。
2.算法:各种常用的算法，如sort、find、copy、for_each等
3.迭代器:扮演了容器与算法之间的胶合剂。
4.仿函数:行为类似函数，可作为算法的某种策略。
5.适配器:一种用来修饰容器或者仿函数或迭代器接口的东西。
6.空间配置器:负责空间的配置与管理。
容器:置物之所也
STL容器就是将运用最广泛的一些数据结构实现出来常用的数据结构:数组,链表,树,栈,队列,集合,映射表等
这些容器分为序列式容器和关联式溶容器两种:
序列式容器:强调值的排序，序列式容器中的每个元素均有固定的位置。
关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系
算法:问题之解法也
有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)算法分为:
质变算法和非质变算法。
质变算法:是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等
非质变算法∶是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等
迭代器:容器和算法之间粘合剂
提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。
每个容器都有自己专属的迭代器，迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针
算法必须要通过迭代器来访问容器中的元素
在这里插入图片描述
常用的容器中迭代器种类为双向迭代器和随机访问迭代器

vector容器存放内置数据类型

STL中最常用的容器为Vector，可以理解为数组，利用这个容器中可以实现插入数据、并遍历这个容器
在这里插入图片描述
iterator是迭代器的名称，是在vector类型下的
在这里插入图片描述

//#define _CRT_SECURE_NO_WARNINGS
//#include <iostream>
//using namespace std;
//int main()
//{
//	system("pause");
//	return EXIT_SUCCESS;
//}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>//标准算法的头文件
//vector容器存放内置数据类型

void myPrint(int val)
{
	cout << val << endl;
}

void test01()
{
	//创建了一个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()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
第三种函数的源码:
这里是用了回调函数还有一个for循环来实现的
这里的迭代器可以看成指针，而解引用就是解这个指针，然后把解引用的元素放入到回调函数进行调用
解引用是解这个迭代器，也就是传入数组中的数
在这里插入图片描述

vector容器中存放自定义数据类型

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#include <vector>
#include <string>

//vector存放自定义的数据类型
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};

void test01()
{
	vector<Person>v;
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);

	//向容器中添加数据
	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;
		//cout << "姓名:" << it->m_Name << " 年龄:" << it->m_Age << endl;
	}
}

//存放自定义数据类型的指针
void test02()
{
	vector<Person*>v;
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);

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

	//遍历容器
	//此时的it可以理解为二级指针
	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "姓名:" << (*it)->m_Name << " 年龄:" << (*it)->m_Age << endl;
	}
}

int main()
{
	//test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

vector容器嵌套vector容器

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;

//容器嵌套容器
void test01()
{
	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()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

string容器——构造函数

string本质:
string是C++风格的字符串，而string本质上是一个类string和char区别:
char是一个指针
string是一个类，类内部封装了char，管理这个字符串，是一个char型的容器。
特点:
string类内部封装了很多成员方法
例如︰查找find，拷贝copy，删除delete替换replace，插入insertstring管理char所分配的内存，不用担心复制越界和取值越界等由类内部进行负责*
在这里插入图片描述

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

//string的构造函数
void test01()
{
	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()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

string容器——赋值操作

在这里插入图片描述

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

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

	string str2;
	str2 = str1;
	cout << "str2=" << str1 << 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);
	cout << "str5=" << str5 << endl;

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

	string str7;
	str7.assign(10, 'w');
	cout << "str7=" << str7 << endl;
}

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

在这里插入图片描述

string容器——字符串拼接

在这里插入图片描述

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

//string字符凭借

void test01()
{
	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 ");//append中文是增加
	cout << "str3=" << str3 << endl;

	str3.append("game abcde", 4);
	cout << "str3=" << str3 << endl;

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

	/*str3.append(str2,0,4);
	cout << "str3=" << str3 << endl;*/

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

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

在这里插入图片描述

string容器——字符串的查找和替换

在这里插入图片描述
第一个函数原型：查找的是数组的下标，查找不到就输出-1
在这里插入图片描述
在这里插入图片描述

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

//string 字符串的查找和替换

//1、查找 find
void test01()
{
	string str1 = "abcdefgde";
	int pos = str1.find("de");
	cout << "pos=" << pos << endl;
	int abc = str1.find("df");
	cout << "abc=" << abc << endl;
	
//1、查找 rfind
	pos = str1.rfind("de");
	cout << "pos=" << pos << endl;

	//rfind和find区别
	//rfind从右往左查  find从左往右查
}

//2、替换
void test02()
{
	string str1 = "abcdefg";
	//从1号位置起3个字符替换为"1111"
	str1.replace(1, 3, "1111"); //把bcd换成1111 
	cout << "str1=" << str1 << endl;
}

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

在这里插入图片描述

string容器——字符串比较

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

//string 字符串比较
void test01()
{
	string str1 = "hello";
	string str2 = "hello";

	if (str1.compare(str2) == 0)
	{
		cout << "str1 等于 str2" << endl;
	}
	else if (str1.compare(str2) > 0)
	{
		cout << "str1 大于 str2" << endl;
	}
	else if (str1.compare(str2) < 0)
	{
		cout << "str1 小于 str2" << endl;
	}
}

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

在这里插入图片描述
总结:字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小的意义并不是很大

string容器——字符存取

在这里插入图片描述

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

//string 字符存取
//底层是字符数组

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

	//修改单个字符
	str[0] = 's';
	cout << "str=" << str << endl;

	str.at(1) = 'b';
	cout << "str=" << str << endl;
}

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

在这里插入图片描述

string容器——字符串的插入和删除

在这里插入图片描述

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

//string 字符串的插入和删除
void test01()
{
	string str = "hello";

	//插入
	str.insert(1, "111");
	cout << "str=" << str << endl;

	//删除
	str.erase(1, 3);
	cout << "str=" << str << endl;
}

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

在这里插入图片描述

string容器——字串获取

在这里插入图片描述

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

//string 字串获取
void test01()
{
	string str = "abcdef";
	//数组下标为1往后数三个
	string subStr = str.substr(1, 3);
	cout << "subStr=" << subStr << endl;
}

//实用操作
void test02()
{
	string email = "zhangsan@sina.com";
	//从邮件的地址中  获取  用户名的信息
	int pos = email.find("@");
	cout << pos << endl;
	string userName = email.substr(0, pos);//从email数组下标为0的元素开始截取8哥字符
	cout << userName << endl;
}

int main()
{
	//test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

这里find找到@的位置为8是数组下标，我们要截取的zhangsan这个字符串长度也是8，直接把pos传进去就行了
在这里插入图片描述
总结:灵活的运用求子串功能，可以在实际开发中获取有效的信息

vector容器——构造函数

功能:
vector数据结构和数组非常相似，也称为单端数组
vector与普通数组区别:
不同之处在于数组是静态空间，而vector可以动态扩展
动态拓展:
并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间
在这里插入图片描述
vector的迭代器是支持随机访问的迭代器
这里的begin()是闭区间，end()是开区间
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;

void printVector(vector<int>&v)
{
	//vector容器可以看成数组
	//迭代器可以看成指针
	//在C++中，vector是一个动态数组，可以根据需要自动扩展或缩小。
	//v.begin()是vector容器的一个成员函数，它返回一个指向容器中第一个元素的迭代器。
	//所以创建了一个名为v的vector容器，v.begin()将返回一个指向v中第一个元素的迭代器
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//vector容器
void test01()
{
	vector<int>v1;

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

	printVector(v1);

	//通过区间方式进行构造
	//这里调用了构造函数
	vector<int>v2(v1.begin(), v1.end());
	printVector(v2);

	//n个elem方式构造
	//第一个参数是个数  第二个是赋值
	vector<int>v3(10, 100);
	printVector(v3);

	//拷贝构造
	vector<int>v4(v3);
}

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

这里打印函数为什么要加入引用的原因是：
不加引用程序就需要重新构建一个vector，这会浪费很多的计算机资源，加引用就是为了避免这个的

vector容器——赋值操作

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;

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

//vector赋值
void test01()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);
	//赋值 operator=
	vector<int>v2;
	v2 = v1;
	printVector(v2);

	//assign
	vector<int>v3;
	//前闭后开
	v3.assign(v1.begin(), v1.end());
	printVector(v3);

	//n个elem方式赋值
	vector<int>v4;
	v4.assign(10, 100);
	printVector(v4);
}

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

在这里插入图片描述

vector容器——容量和大小

在这里插入图片描述
判断是否为空— empty
返回元素个数— size
返回容器容量— capacity
重新指定大小 — resize

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;

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

//vector容器的容量和大小操作
void test01()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	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,100);//利用重载版本，可以指定默认的填充值
	printVector(v1);//如果重新指定的比原来长了 默认用0填充

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

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

在这里插入图片描述

vector容器——插入和删除

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;

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

//vector插入和删除
void test01()
{
	vector<int>v1;
	//尾插
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);

	//遍历
	printVector(v1);

	//尾删
	v1.pop_back();
	printVector(v1);

	//插入
	v1.insert(v1.begin(), 100);//传入参数是一个迭代器进行插入
	printVector(v1);

	v1.insert(v1.begin(), 2, 1000);
	printVector(v1);

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

	//类似于情况的操作
	//v1.erase(v1.begin(), v1.end());
	v1.clear();
	printVector(v1);
}

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

在这里插入图片描述

vector容器——数据存取

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;

//vector容器  数据存取

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

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

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

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

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

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

在这里插入图片描述
总结:
除了用迭代器获取vector容器中元素，[]和l也可以
front返回容器第一个元素
back返回容器最后一个元素

vector容器——互换容器

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;

//vector容器互换

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

//1、基本使用
void test01()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	cout << "交换前:" << endl;
	printVector(v1);

	vector<int>v2;
	for (int i = 10; i > 0; i--)
	{
		v2.push_back(i);
	}
	printVector(v2);

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

//2、实际用途
//可以巧用swap可以收缩内存空间
void test02()
{
	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)//匿名对象  调用了一次拷贝构造函数
	//用v所用的内存空间来初始化x的内存空间
	//.swap(v)相当于容器之间的交换
	//匿名对象的特点 执行完就会回收空间
	vector<int>(v).swap(v);
	cout << "v的容量: " << v.capacity() << endl;
	cout << "v的大小: " << v.size() << endl;
}

int main()
{
	//test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

vector容器——预留空间

功能：
减少vector在动态扩展容量时的扩展次数
在这里插入图片描述
没有设置预留空间：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;

//vector容器  预留空间
void test01()
{
	int num = 0;//统计开辟次数
	int *p = NULL;
	vector<int>v;
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);

		if (p!=&v[0])
		{
			p = &v[0];
			num++;
		}
	}
	cout << "num=" << num << endl;
}

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

在这里插入图片描述
设置了预留空间：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;

//vector容器  预留空间
void test01()
{
	int num = 0;//统计开辟次数
	int *p = NULL;
	vector<int>v;
	//利用reserve来预留空间
	v.reserve(100000);
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);

		if (p!=&v[0])
		{
			p = &v[0];
			num++;
		}
	}
	cout << "num=" << num << endl;
}

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

在这里插入图片描述

deque容器——构造函数

功能:双端数组，可以对头端进行插入删除操作
deque与vector区别:
vector对于头部的插入删除效率低，数据量越大，效率越低.
deque相对而言，对头部的插入删除速度回比vector快
vector访问元素时的速度会比deque快,这和两者内部实现有关
我的理解是双端队列
在这里插入图片描述
在这里插入图片描述
deque内部工作原理:
deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据
中控器维护的是每个缓冲区的地址，使得使用deque时象一片连续的内存空间
deque容器的迭代器也是支持随机访问的
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <deque>
using namespace std;

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

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

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

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

	deque<int>d4(d3);
	printDeque(d4);
}

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

在这里插入图片描述

deque容器——赋值操作

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <deque>
using namespace std;

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

//deque容器赋值操作
void test01()
{
	deque<int>d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);

	//operator=赋值
	deque<int>d2;
	d2 = d1;
	printDeque(d2);

	//assign 赋值
	deque<int>d3;
	d3.assign(d1.begin(), d1.end());
	printDeque(d3);

	deque<int>d4;
	d4.assign(10, 100);
	printDeque(d4);

}

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

在这里插入图片描述

deque容器——大小操作

deque相较于vector少了容量操作，也就是说容量没有限制

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <deque>
using namespace std;

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

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

	if (d1.empty())
	{
		cout << "d1为空" << endl;
	}
	else
	{
		cout << "d1不为空" << endl;
		cout << "d1的大小为:" << d1.size() << endl;
		//deque容器没有容量概念
	}

	//重新指定大小
	//d1.resize(15);
	d1.resize(15, 1);
	printDeque(d1);

	d1.resize(5);
	printDeque(d1);
}

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

在这里插入图片描述

deque容器——插入和删除

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <deque>
using namespace std;

//deque容器的插入和删除

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

//两端操作
void test01()
{
	deque<int>d1;

	//尾插
	d1.push_back(10);
	d1.push_back(20);

	//头插
	d1.push_front(100);
	d1.push_front(200);
	printDeque(d1);

	//尾删
	d1.pop_back();
	printDeque(d1);

	//头删
	d1.pop_front();
	printDeque(d1);
}

void test02()
{
	deque<int>d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(100);
	d1.push_front(200);
	printDeque(d1);

	//insert插入
	d1.insert(d1.begin(), 1000);
	printDeque(d1);

	d1.insert(d1.begin(), 2, 10000);
	printDeque(d1);

	//按照区间进行插入
	deque<int>d2;
	d2.push_back(1);
	d2.push_back(2);
	d2.push_back(3);
	
	//插入d2.begin()到d2.end()的区间的数
	d1.insert(d1.begin(), d2.begin(), d2.end());
	printDeque(d1);
}

void test03()
{
	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(it);
	printDeque(d1);
	//d1.erase(d1.begin() + 1);
	//printDeque(d1);

	//按照区间的方式删除
	d1.erase(d1.begin(), d1.end());
	printDeque(d1);

	//清空
	d1.clear();
	printDeque(d1);
}

int main()
{
	test01();
	cout << "------------------------------" << endl;
	test02();
	cout << "------------------------------" << endl;
	test03();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

deque容器——数据存储

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <deque>
using namespace std;

void test01()
{
	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;

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

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

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

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

在这里插入图片描述

deque容器——排序操作

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;

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

//deque容器 排序操作

void test01()
{
	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);
	// 300 200 100 10 20 30

	printDeque(d);

	//排序
	//sort算法默认的排序规则 从小到大 升序
	//对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序
	//vector容器佝可以利用sort讲行排序
	sort(d.begin(),d.end());
}

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

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/631517.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

人工智能该如何学习？详细的AI学习

人工智能该如何学习？详细的AI学习

Yan-英杰的主页 悟已往之不谏 知来者之可追 C程序员&#xff0c;2024届电子信息研究生 1.TomChat 地址&#xff1a;https://www.ridderchat.com/ 该网站非常简介好看&#xff0c;界面看着很舒服&#xff0c;可以帮助你快速编写、编辑和讨论代码。 2.强大的AI辅助 链接…
阅读更多...
模拟实现strstr函数，通俗易懂！！！

模拟实现strstr函数，通俗易懂！！！

函数介绍 函数声明 函数声明&#xff1a;char *strstr(const char *str1, const char *str2) 头 文 件&#xff1a;#include <string.h> 返 回 值&#xff1a; 返回值为char * 类型&#xff08; 返回指向 str1 中第一次出现的 str2 的指针&#xff09;&#xff1b…
阅读更多...
Webots R2021a教程

Webots R2021a教程

文章目录 Windows安装设置中文打开世界添加贴图 为外部控制器配置Anaconda解决报错&#xff1a;CondaSSLError: Encountered an SSL error. Most likely a certificate verification issue.调用Python API Windows 安装 进入下载页面 https://github.com/cyberbotics/webots/r…
阅读更多...
CSS实现几种常见布局

CSS实现几种常见布局

CSS实现几种常见布局 两列左窄右宽型布局 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta http-equiv"X-UA-Compatible" content"IEedge"><meta name"viewport" co…
阅读更多...
【面试题】2023前端面试系列-- Vue 篇

【面试题】2023前端面试系列-- Vue 篇

大厂面试题分享 面试题库 前后端面试题库 &#xff08;面试必备&#xff09; 推荐&#xff1a;★★★★★ 地址&#xff1a;前端面试题库 web前端面试题库 VS java后端面试题库大全 Vue 常见面试题总结 MVVM模型&#xff1f; MVVM&#xff0c;是Model-View-ViewModel的简写…
阅读更多...
001docker架构介绍

001docker架构介绍

docker 官网Choose the best method for you to install Docker Engine. This client-server application is available on Linux, Mac, Windows, and as a static binary.https://docs.docker.com/engine/install/ 介绍 Docker用Go编程语言编写&#xff0c;并利用Linux内核的…
阅读更多...
算法刷题-链表-两两交换链表中的节点

算法刷题-链表-两两交换链表中的节点

两两交换链表中的节点 24. 两两交换链表中的节点思路其他语言版本 24. 两两交换链表中的节点 力扣题目链接 给定一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后的链表。 你不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。 思…
阅读更多...
黄金回收小程序开发功能有哪些？

黄金回收小程序开发功能有哪些？

一、用户端&#xff1a; 1、实时查询&#xff1a;通过对接三方接口实现实时金价动态查看&#xff1b; 2、多种类珠宝实时回收&#xff1a;小程序支持多品类珠宝的实时回收包含黄金饰品、金条、铂金、K金、白银等&#xff0c;同步实现价格实时更新&#xff1b; …
阅读更多...
计算机内核态、用户态和零拷贝技术详解

计算机内核态、用户态和零拷贝技术详解

存储介质的性能 话不多说&#xff0c;先看一张图&#xff0c;下图左边是磁盘到内存的不同介质&#xff0c;右边形象地描述了每种介质的读写速率。一句话总结就是越靠近cpu&#xff0c;读写性能越快。了解了不同硬件介质的读写速率后&#xff0c;你会发现零拷贝技术是多么的香&a…
阅读更多...
JDBC 事务和批处理 详解（通俗易懂）

JDBC 事务和批处理 详解（通俗易懂）

目录 一、前言 二、事务 1.事务介绍 : 2.事务处理 : Δ准备工作 Δ不使用事务的情况 Δ使用事务的情况 三、批处理 1.介绍 : 2.常用方法 : 3.应用 : 4.源码分析(JDK17.0版本&#xff09; : 四、总结 一、前言 第四节内容&#xff0c;up主要和大家…
阅读更多...
阿里背调，征信不好也会被pass

阿里背调，征信不好也会被pass

大厂背调&#xff0c;我一直认为是唬人的&#xff0c;走下流程而已&#xff0c;没想到这么严格。这次提供的背调信息&#xff0c;我填写了上家公司三个联系人&#xff0c;HR、领导、同事&#xff1b;上上家公司三个联系人&#xff0c;HR、领导、同事。根据朋友的反馈来看&#…
阅读更多...
python 第五章 列表list [ ]

python 第五章 列表list [ ]

系列文章目录 第一章 初识python 第二章 变量 第三章 基础语句 第四章 字符串str 文章目录 5.1列表的应用场景5.2列表的格式5.3列表的常用操作查找下标函数查找函数index()count()len() 判断是否存在innot in 增加append()extend()insert() 删除delpop()remove()clear() 清空列…
阅读更多...
Java并发回顾

Java并发回顾

树叶柔和爽朗的呼吸 诗人一路吹着口哨回家 一路踢着石子妙想连篇 感到夕阳和晚风自古多情 自己现在和将来 都是个幸福的人 系列文章目录 Java常见知识点汇总Java集合回顾Java并发回顾… 文章目录 系列文章目录什么是线程和进程?线程与进程的关系,区别及优缺点&#xff1f;图解…
阅读更多...
Tcp的三次握手及netty和实际开发如何设置全连接队列参数

Tcp的三次握手及netty和实际开发如何设置全连接队列参数

上图 第一次握手&#xff0c;client 发送 SYN 到 server&#xff0c;状态修改为 SYN_SEND&#xff0c;server 收到&#xff0c;状态改变为 SYN_REVD&#xff0c;并将该请求放入 sync queue 队列 第二次握手&#xff0c;server 回复 SYN ACK 给 client&#xff0c;client 收到…
阅读更多...
【Prometheus】mysqld_exporter采集+Grafana出图+AlertManager预警

【Prometheus】mysqld_exporter采集+Grafana出图+AlertManager预警

前提环境&#xff1a;已经安装和配置好prometheus server 所有组件对应的版本&#xff1a; prometheus-2.44.0 mysqld_exporter-0.14.0 grafana-enterprise-9.1.2-1.x86_64.rpm alertmanager-0.25.0 prometheus-webhook-dingtalk-2.1.0 简介 mysql_exporter是用来收集MysQL或…
阅读更多...
spring 事务超时

spring 事务超时

Transactional(timeout 10) 表示设置事务的超时时间为10秒 表示超过10秒如果该事务中所有的DML语句还没有执行完毕的话&#xff0c;最终结果会选择回滚 默认值-1&#xff0c;表示没有时间限制。 如果最后一条DML语句后面还有很多业务逻辑&#xff0c;这些业务代码执行的时间不…
阅读更多...
setState详解

setState详解

this. setState( [partialState], [callback]) 1.[partialState] :支持部分状态更改 this, setState({ x:100 //不论总共有多少状态&#xff0c;我们只修改了x&#xff0c;其余的状态不动 });callback :在状态更改/视图更新完毕后触发执行&#xff0c;也可以说只要执行了setS…
阅读更多...
lightGBM的介绍

lightGBM的介绍

一、lightGBM的介绍 1.lightGBM的演进过程 2.AdaBoost算法 AdaBoost&#xff08;Adaptive Boosting&#xff09;是一种集成学习算法&#xff0c;通过组合多个弱分类器来构建一个强分类器。它是由Freund和Schapire在1996年提出的&#xff0c;是集成学习中最早被广泛应用的算法…
阅读更多...
JDK8-1-Lambda表达式（5）-复合 Lambda 表达式

JDK8-1-Lambda表达式（5）-复合 Lambda 表达式

JDK8-1-Lambda表达式&#xff08;5&#xff09;-复合 Lambda 表达式 JDK8 在 java.util.function 包下定义了一些默认的 函数式接口 &#xff0c;如 Predicate、Consumer、Function、 Comparator &#xff08;在 java.util.包下&#xff09; &#xff0c;这些接口提供了一些复…
阅读更多...
运营-21.常见的内容生产方式

运营-21.常见的内容生产方式

常见的 内容生产方式 PGC&#xff08;Professionally-generated Content&#xff09;专业生产内容 传统的门户网站内容生产方式&#xff0c;内容多由官方工作人员身或者专业的内容创造者&#xff08;比如新闻记者等&#xff09;创造。 UGC&#xff08;User Generated Content&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023