c++学习20STL(二) 常用容器1

最新推荐文章于 2024-04-01 09:36:13 发布
最新推荐文章于 2024-04-01 09:36:13 发布
阅读量228 收藏 1
点赞数 1
分类专栏： C++ 文章标签： c++ 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46066548/article/details/126606258
版权
本文详细介绍了C++ STL中的string容器，包括其基本概念、与char*的区别、构造函数、赋值操作、字符串拼接、查找替换、字符存取、插入删除以及数据存取。此外，还对比了vector和deque的特性和应用场景，如动态扩展和随机访问。
摘要由CSDN通过智能技术生成

STL常见容器

string容器

string的基本概念

本质：
string是c++的风格的字符串，而string本质上是一个类
string和char*的区别：
char* 是一个指针
string是一个类，类内部封装了char*,管理这个字符串的是一个char*型的容器
特点：

  1. string内部封装了很多成员方法
  2. string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部负责

string构造函数

  1. string();
  2. string (const char *s)；
  3. string (const string& str)；
  4. string(int n,char c);
#include<iostream>
using namespace std;
#include<string>

//string 的构造函数
void test01() {
	//创建一个空字符串  string();
	string s1;
	cout << s1 << endl;
	//用字符串s 进行初始化  string (const char *s)
	const char* s = "明天，你好";
	string s2(s);
	cout << s2 << endl;
	//使用一个string对象，初始化另一个string对象 string (const string& str)
	string s3(s2);
	cout << s3 << endl;
	//使用n个字符初始化  string(int n,char c）
	string s4(10, 'w');
	cout << s4 << endl;

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

string的赋值操作

  1. sting& operator=(const chars); --------char字符串赋值给当前字符串
  2. sting& operator=(const string &s); --------把字符串s赋值给当前字符串
  3. sting& operator=(const char c); --------字符c赋值给当前字符串
  4. sting& assign(const char*s); --------把字符串s赋值给当前字符串
  5. sting& assign(const char*s,int n); --------把字符串s的前n个字符赋值给当前字符串
  6. sting& assign(const string &s); --------把字符串s赋值给当前字符串
  7. sting& assign(int n,char c); --------把n个字符c赋值给当前字符串
#include<iostream>
using namespace std;
#include<string>
//string 赋值操作
//1. sting & operator=(const char* s); --------char* 字符串赋值给当前字符串
//2. sting & operator=(const string & s); --------把字符串s赋值给当前字符串
//3. sting & operator=(const char c); --------字符c赋值给当前字符串
//4. sting & assign(const char* s); --------把字符串s赋值给当前字符串
//5. sting & assign(const char* s, int n); --------把字符串s的前n个字符赋值给当前字符串
//6. sting & assign(const string & s); --------把字符串s赋值给当前字符串
//7. sting & assign(int n, char c); --------把n个字符c赋值给当前字符串

void test01() {
	const char* s = "你好呀";
	string s1 = s;
	cout << s1 << endl;

	string s2 = s1;
	cout << s2 << endl;

	//string s3 = 'a';//连等报错
	string s3;
	s3 = 'a';
	cout << s3 << endl;

	string s4;
	s4.assign("明天见");
	cout << s4 << endl;

	string s5;
	s5.assign("abcdefj", 3);
	cout << s5 << endl;

	string s6;
	s6.assign(s1);
	cout << s6 << endl;

	string s7;
	s7.assign(6, 'a');
	cout << s7 << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

字符串拼接

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

函数原型

运算符+=重载：

  1. sting& operator+=(const char* str);
  2. sting& operator+=(const string &s);
  3. sting& operator+=(const char c);
    append方法：
  4. sting& appendconst char*s); --------把字符串s连接到当前字符串结尾
  5. sting& append(const char*s,int n); --------把字符串s的前n个字符连接到当前字符串结尾
  6. sting& append(const string &s); --------相当于operator+=(const string &s);
  7. sting& append(const string &s，int pos,int n); --------字符串s中从pos开始的n个字符连接到当前字符串结尾
#include<iostream>
using namespace std;
#include<string>
//字符串拼接
//运算符 += 重载：
//1. sting & operator+=(const char* str);
//2. sting & operator+=(const string & s);
//3. sting & operator+=(const char c);
//append方法：
//4. sting & append（const char* s); --------把字符串s连接到当前字符串结尾
//5. sting & append(const char* s, int n); --------把字符串s的前n个字符连接到当前字符串结尾
//6. sting & append(const string & s); --------相当于operator += (const string & s);
//7. sting & append(const string & s，int pos, int n); --------字符串s中从pos开始的n个字符连接到当前字符串结尾
void test01() {
	string s = "确实";
	string s1 = "我爱学习";
	cout << s1 << endl;
	s1 += "?你在开玩笑吗";
	cout << s1 << endl;
	s1 += '!';
	cout << s1 << endl;
	//中文占2个字符
	string s2 = "今天天气真不错";
	cout << s2 << endl;
	s2.append(",hhh");
	cout << s2 << endl;
	s2.append(s);
	cout << s2 << endl;
	s2.append("快别说了，这都啥呀？", 4);
	cout << s2 << endl;
	s2.append(s1, 4, 5);
	cout << s2 << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

字符串查找和替换

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

函数原型
  1. int find(const string& str,int pos=0) const; //查找str第一次出现的位置，从pos开始查找
  2. int find(const char* s,int pos=0) const; //查找s第一次出现的位置，从pos开始查找
  3. int find(const char* s,int pos=0,int n) const; //从pos开始查找s的前n个字符第一次出现的位置
  4. int find(const char c) const; //查找字符c第一次出现的位置
  5. int rfind(const string& str,int pos=npos) const; //查找str最后一次出现的位置，从pos开始查找
  6. int rfind(const char* s,int pos=npos) const; //查找s最后一次出现的位置，从pos开始查找
  7. int rfind(const char* s,int pos=npos,int n) const; //从pos开始查找s的前n个字符最后一次出现的位置
  8. int rfind(const char c) const; //查找字符c最后一次出现的位置
  9. string &replace(int pos,int n,const string &str);替换从pos开始的n个字符为字符串str
  10. string &replace(int pos,int n,const char* s);替换从pos开始的n个字符为字符串s
    一些说明写在代码里面了，不重复说明
#include<iostream>
using namespace std;
#include<string>
//字符串的查找
void test01() {
	string s1 = "abcdefghtcd";
	int pos=s1.find("cd");
	cout << pos << endl; //2 说明字符串的下标是从0开始的，且返回的是查找目标字符串的首个字符对应第一次的位置
	int res = s1.find("wd");
	cout << res << endl;//-1 对于在字符串中没有的目标字符串，返回值为-1

	int pos1 = s1.rfind("cd");
	cout << pos1 << endl;//9 rfind是从右往左查的，find是从左往右，但返回的都是目标字符串的首个字符的位置，即rfind查找的是最后一次出现的位置

}
//字符串的替换
void test02() {
	string s1 = "abcdefghtcd";
	s1.replace(2, 4, "开始了");//替换的是字符串本身，替换的2，4都是字符串本身的位置个数说明，目标字符串（要替换成）会全部替换到字符串上，不会管字符串本身替换的字符个数
	cout << s1 << endl;
}
int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

字符串比较

功能描述：

字符串之间的比较

比较方式：

字符串的比较是按字符的ASCII码进行对比的
“=” 返回 0
“>” 返回 1
“<” 返回 -1

函数原型
  1. int compare(const string &str) const; //与字符串str进行比较
  2. int compare(const char * s) const; //与字符串s进行比较
#include<iostream>
using namespace std;
#include<string>
//字符串比较 最大用途是比较是否相等，对于大小比较并没有实在意义
void test01() {
	string s1 = "abcde";
	string s2 = "abcde";
	string s3 = "abdde";
	string s4 = "abbde";

	cout << s1.compare(s2) << endl;//0
	cout << s1.compare(s3) << endl;//-1
	cout << s1.compare(s4) << endl;//1
	
}
int main() {
	test01();
	system("pause");
	return 0;
}

string字符存取

  1. char& operator[](int n) //通过[]取字符串
  2. char& at(int n) //通过at方式获取字符串
#include<iostream>
using namespace std;
#include<string>
//字符串存取
void test01() {
	//由于中文是占2个字符的，获取会导致读取失败，输出?几个中文输出两倍的字符'?'
	string s = "hello,你好";
	//通过[]获取
	for (int i = 0;i < s.size();i++) {
		cout << s[i] << " ";
	}
	cout << endl; // h e l l o , ????
	//通过at获取
	for (int i = 0;i < s.size();i++) {
		cout << s.at(i) << " ";
	}
	cout << endl; // h e l l o , ????

	//修改单个字符
	s[0] = 'c';
	cout << s << endl; //cello,你好
	s.at(1) = 'c';
	cout << s << endl;//ccllo,你好

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

string插入与删除

函数原型
  1. string& insert(int pos,const char *s); //插入字符串
  2. string& insert(int pos,const string& str); //插入字符串
  3. string& insert(int pos,int n,char c);//在指定位置pos插入n个字符c
  4. string& erase(int pos,int n =npos); //删除从pos开始的n个字符
#include<iostream>
using namespace std;
#include<string>
//string的插入与删除
//1. string & insert(int pos, const char* s);   //插入字符串
//2. string & insert(int pos, const string & str); //插入字符串
//3. string & insert(int pos, int n, char c);//在指定位置pos插入n个字符c
//4.  string & erase(int pos, int n = npos); //删除从pos开始的n个字符
void test01() {
	//string的插入
	string s = "hello,你好";
	const char* s1 = "512";
	s.insert(4, s1);
	cout << s << endl;//hell512o,你好
	s.insert(1, "我是新增的字符串");
	cout << s << endl;//h我是新增的字符串ell512o,你好
	s.insert(0, 6, 'd');
	cout << s << endl;//ddddddh我是新增的字符串ell512o,你好
	//string 的删除
	s.erase(0, 5);
	cout << s << endl;//dh我是新增的字符串ell512o,你好


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

string容器—字串获取

功能描述：

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

函数原型:

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

#include<iostream>
using namespace std;
#include<string>
//string获取子串

void test01() {
	string s = "hello,你好";
	string subS = s.substr(2, 5);
	cout << s << endl;
	cout << subS << endl;//若字符串的截取个数恰好读到中文时，只有一个字符串，那么中文不显示
}
void test02() {
	string s1 = "wujinlong@qq.com";
	int pos = s1.find('@');
	string sub = s1.substr(0, pos);
	cout << "截取到的用户名为：" << sub << endl;//截取到的用户名为：wujinlong
}
int main() {
	test01();
	//截取字符串的应用
	test02();
	system("pause");
	return 0;
}

vector容器

基本概念

vector数据结构和数组非常相似，也称为单端数组
不同在于数组时静态空间，而vector可以动态扩展
动态扩展：
并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

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

vector构造容器

函数原型：

  1. vector v; //采用模板实现类实现，默认构造函数
  2. vector(v.begin() , v.end()); //将**v[begin(),end())**区间中的元素拷贝给本身
  3. vector(n,elem); //构造函数将n个elem拷贝给本身
  4. vector(const vector &vec); //拷贝构造函数
#include<iostream>
using namespace std;
#include<vector>
//vector构造函数
//1. vector<T> v; //采用模板实现类实现，默认构造函数
//2. vector(v.begin(), v.end());    //将**v[begin(),end())**区间中的元素拷贝给本身
//3. vector(n, elem);    //构造函数将n个elem拷贝给本身
//4. vector(const vector & vec);  //拷贝构造函数

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

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, 9);
	printVector(v3);

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

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

vector赋值操作

函数原型
  1. vector& operator=（const vector &vec); //重载等号操作符
  2. assign(beg,end); //将[beg,end)区间中的数据拷贝赋值给本身
  3. assign(n,elem); //将n个elem拷贝赋值给本身
#include<iostream>
using namespace std;
#include<vector>
//vector赋值操作
//1. vector& operator=（const vector &vec);  //重载等号操作符
//2. assign(beg,end); //将[beg,end)区间中的数据拷贝赋值给本身
//3. assign(n,elem); //将n个elem拷贝赋值给本身

void printVector(vector<int>& vec) {
	for (vector<int>::iterator it = vec.begin();it != vec.end();it++) {
		cout << *it <<" ";
	}
	cout << endl;
}
void test02() {
	vector<int> v5;
	for (int i = 0;i < 10;i++) {
		v5.push_back(i);
	}

	printVector(v5);

	vector<int> v6 = v5;
	printVector(v6);

	vector<int> v7;
	v7.assign(v5.begin(), v5.end());
	printVector(v7);

	vector<int> v8;
	v8.assign(6, 7);
	printVector(v8);
}

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

vector容量和大小

函数原型：
  1. empty(); //判断容器是否为空
  2. capacity(); //容器的容量
  3. size(); //返回容器中元素的个数
  4. resize(int num ); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置；如果容器变短，则末尾超出容器长度的元素要被删除
  5. resize(int num,elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置；如果变短，则末尾超出容器长度的元素要被删除
#include<iostream>
using namespace std;
#include<vector>
//vector容器和大小
//1. empty();  //判断容器是否为空
//2. capacity();    //容器的容量
//3. size();         //返回容器中元素的个数
//4. resize(int num);      //重新指定容器的长度为num，若容器变长，则以默认值填充新位置；如果容器变短，则末尾超出容器长度的元素要被删除
//5. resize(int num, elem);         //重新指定容器的长度为num，若容器变长，则以elem值填充新位置；如果变短，则末尾超出容器长度的元素要被删除


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

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 << "容器不为空" << endl;
		cout << "容器的容量为：" << v1.capacity() << endl;
		cout << "容器的大小为：" << v1.size() << endl;

	}
	//重新指定大小
	v1.resize(15,6);
	printVector(v1);

	v1.resize(3);
	printVector(v1);
}


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

vector插入和删除

函数原型
  1. push_back(ele); //尾部插入元素ele
  2. pop_back(); //删除最后一个元素
  3. insert(const_iterator pos,ele); //迭代器指向位置pos插入元素ele
  4. insert(const_iterator pos,int cout,els); //迭代器指向位置pos插入cout个元素ele
  5. erase(const_iterator pos); //删除迭代器指向的元素
  6. erase(const_iterator start,const_iterator end); //删除迭代器start到end之间的元素
  7. clear(); //删除容器中所有元素
#include<iostream>
using namespace std;
#include<vector>
//vector插入与删除
//1. push_back(ele);      //尾部插入元素ele
//2. pop_back();            //删除最后一个元素
//3. insert(const_iterator pos, ele);  //迭代器指向位置pos插入元素ele
//4. insert(const_iterator pos, int cout, els);  //迭代器指向位置pos插入cout个元素ele
//5. erase(const_iterator pos);     //删除迭代器指向的元素
//6. erase(const_iterator start, const_iterator end);    //删除迭代器start到end之间的元素
//7. clear();              //删除容器中所有元素



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

void test01() {
	vector<int> v1;

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

	printVector(v1);

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

	//插入
	v1.insert(v1.begin(), 100);
	printVector(v1);

	v1.insert(v1.end(), 2, 6);
	printVector(v1);

	//删除
	v1.erase(v1.begin());
	printVector(v1);

	//清空
	v1.erase(v1.begin(), v1.end());
	printVector(v1);
	v1.clear();
	printVector(v1);
	
}


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

vector数据存取

函数原型
  1. at(int idx); //返回索引idx所指的数据
  2. operator[ int idx ]; //返回索引idx所指的数据
  3. front(); //返回容器的第一个元素
  4. back(); //返回容器的最后一个元素
#include<iostream>
using namespace std;
#include<vector>
//vector数据存取
//1. at(int idx);     //返回索引idx所指的数据
//2. operator[ int idx ];    //返回索引idx所指的数据
//3. front();    //返回容器的第一个元素
//4. back();    //返回容器的最后一个元素

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;
	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 0;
}

vector互换容器

功能描述：

实现两个容器内元素进行互换

函数原型

swap(vec); //将vec与本身的元素进行互换

#include<iostream>
using namespace std;
#include<vector>
//vector数据存取
//swap(vec);  //将vec与本身的元素进行互换
void printVector(vector<int>& vec) {
	for (int i = 0;i < vec.size();i++) {
		cout << vec[i] << " ";
	}
	cout << endl;
}
//1.简单使用
void test01() {
	vector<int> v1;
	for (int i = 0;i < 10;i++) {
		v1.push_back(i);//尾插
	}
	printVector(v1);
	vector<int> v2;
	for (int i = 16;i >0;i--) {
		v2.push_back(i);//尾插
	}
	printVector(v2);
	v1.swap(v2);
	printVector(v1);
	printVector(v2);

}

//2. 实际用途
//巧用swap可以收缩内存大小
void test02() {
	vector<int> v3;
	for (int i = 0;i < 100000;i++) {
		v3.push_back(i);//尾插
	}
	cout << "v3的容量为：" << v3.capacity() << endl;
	cout << "v3的大小为: " << v3.size() << endl;
	v3.resize(3);
	cout << "v3的容量为：" << v3.capacity() << endl;
	cout << "v3的大小为: " << v3.size() << endl;
	vector<int>(v3).swap(v3); //创建匿名对象。匿名对象在当前行结束后被系统回收
	cout << "v3的容量为：" << v3.capacity() << endl;
	cout << "v3的大小为: " << v3.size() << endl;
}

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

在这里插入图片描述

vector预留空间

功能描述

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

函数原型

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

#include<iostream>
using namespace std;
#include<vector>
//vector预留空间
//reserve(int len);  //容器预留len个元素长度，预留位置不初始化，元素不可访问

void test01() {
	vector<int> v1;
	
	//预留空间，减少开辟次数
	v1.reserve(100000); //此时num只需一次
	int num = 0;//统计开辟的次数
	int* p = NULL;
	for (int i = 0;i < 100000;i++) {
		v1.push_back(i);
		//
		if (p != &v1[0]) {
			p = &v1[0];
			//如果每次比较p指向的空间都不是vector容器第一个元素所在的地址，则进行一次加号运算
			num++;
		}
	}
	cout << "一共开辟的次数为：" << num << endl;//30

}

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

deque容器

基本概念

功能：

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

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

deque内部工作原理

deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据
中控器维护的时每个缓冲区的地址，使得使用deque时像一片连续的内存空间
在这里插入图片描述
deque容器的迭代器也是支持随机访问的

deque构造函数

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

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);

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

	deque<int> d3(5, 6);
	printDeque(d3);

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

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

deque赋值

函数原型
  1. deque& operator=（const vector &vec); //重载等号操作符
  2. assign(beg,end); //将[beg,end)区间中的数据拷贝赋值给本身
  3. assign(n,elem); //将n个elem拷贝赋值给本身
    和vector的赋值操作一致，不做代码描述

deque大小操作

函数原型
  • deque.empty(); //判断容器是否为空
  • deque.size(); //返回容器中元素的个数
  • deque.resize(num); //重新指定容器的长度为num，如果容器变长，以默认值填充，如果容器变短，超出容器长度的元素被删除
  • deque.resize(num,elem);//重新指定容器的长度为num，如果容器变长，以elem填充，如果容器变短，超出容器长度的元素被删除
#include<iostream>
using namespace std;
#include<deque>
//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;
	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;
	}
	d1.resize(11);
	printDeque(d1);
	d1.resize(12, 5);
	printDeque(d1);

}

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

总结：
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位置的数据，返回下一个数据的位置

总结：
插入和删除的位置只能是迭代器，不能是特定的值，但可以通过偏移迭代器而拿到除开始和结尾的位置

#include<iostream>
using namespace std;
#include<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位置的数据，返回下一个数据的位置
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);
	printDeque(d1);
	//头插
	d1.push_front(1);
	d1.push_front(2);
	printDeque(d1);

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

}
//指定位置的操作
void test02() {
	deque<int> d2;
	d2.insert(d2.begin(), 1);
	printDeque(d2);
	d2.insert(d2.begin(), 5,6);
	printDeque(d2);

	deque<int> d3;
	for (int i = 0;i < 4;i++) {
		d3.push_back(i);
	}
	printDeque(d3);

	d2.insert(d2.begin(), d3.begin(), d3.end());
	printDeque(d2);
	
	d3.clear();
	printDeque(d3);
	d2.erase(d2.begin());
	printDeque(d2);
	d2.erase(d2.begin(), d2.end());
	printDeque(d2);

}

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

deque数据存取

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

deque容器的排序操作

利用算法实现对deque容器进行排序
（对于支持随机访问的迭代器容器，都可以通过sort算法直接对其进行排序）
sort()算法默认支持升序排序

 sort(iterator beg, iterator end)   //对beg和end区间内元素进行排序

容器使用小案例-评委打分

案例描述

有5名选手：ABCDE,10个评委分别对每一个选手打分，去除最高分和最低分，取平均分

实现步骤

  1. 创建五名选手，放到vector中
  2. 遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中
  3. sort算法对deque容器中分数进行排序，去除最高分和最低分
  4. deque容器再遍历一遍，累加总分
  5. 获取平均分
    注：同学习视频有部分不同，主要体现在遍历的方式，大致相同，实现的效果也是相同的
#include<iostream>
using namespace std;
#include<deque>
#include<string>
#include<vector>
#include<algorithm>
#include<ctime>
//选手类
class Person {
public:
	Person(string name, int score) {
		this->m_Name = name;
		this->m_Score = score;
	}

	string m_Name;
	int m_Score;
};
//打印选手姓名和平均分
void printVector(vector<Person>& vec) {
	for (vector<Person>::iterator it = vec.begin();it != vec.end();it++) {
		cout << (*it).m_Name << " 平均分： " << (*it).m_Score << endl;
	}
}
//创建vector容器中的选手，并对其进行初始化
void createPerson(vector<Person> &vec) {
	for (int i = 0;i < 5;i++) {
		string mName = "ABCDE";
		string name = "选手";
		name += mName[i];
		int age = 0;
		Person p(name, age);
		vec.push_back(p);
	}
}
//设置每位选手的得分情况
void setScore(vector<Person>& vec) {
	for (int i = 0;i < 5;i++) {
		//创建存放分数的容器
		deque<int> d;
		cout << vec[i].m_Name << "打分：" << endl;
		for (int j = 0;j < 10;j++) {
			int mScore = rand() % 41 + 60;  //分数区间为60~100
			//
			cout << mScore << " ";
			d.push_back(mScore);
		}
		cout << endl;
		//对分数进行排序
		sort(d.begin(), d.end());
		//去除最高分和最低分
		d.pop_back();
		d.pop_front();

		//获取总分
		int sum = 0;
		for (int i = 0;i <d.size();i++) {
			sum += d[i];
		}
		cout << "去除最高分和最低分后的总分：" << endl;
		cout << sum << endl;
		//取平均分
		int score = sum /d.size();
		vec[i].m_Score = score;

	}
}
int main() {
	//加入随机数种子，使每次实现不一样
	srand((unsigned int)time(NULL));
	vector<Person> v;
	createPerson(v);
	setScore(v);
	printVector(v);
	system("pause");
	return 0;
}
言顶
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL常用容器详细解析
01-20
STL中的常用容器包括：顺序性容器（vector、deque、list）、关联容器（map、set）、容器适配器（queue、stac）。 1、顺序性容器 （1）vectorvector是一种动态数组，在内存中具有连续的存储空间，支持快速随机访问。...
C++STL库常用库函数总结
07-08
以下是对C++ STL库中常用库函数的详细总结： 1. **vector** - `size()`：返回向量中元素的数量。 - `empty()`：检查向量是否为空。 - `clear()`：清空向量的所有元素。 - `front()` / `back()`：访问第一个和...
C++ 20 —— STL
xaphoenix的博客
06-11 558
源码// 20STL.cpp : Defines the entry point for the console application. //#include "stdafx.h" #include "iostream.h" #include "vector" using namespace std;int main(int argc, char* argv[]) { vector<int
容器和算法的改进 --- C++20
qq_42896106的博客
06-18 253
对容器和算法有很多的改进这样, 你就可以实现在编译期查找字符串子串, 在编译期对数组进行排序 之所以能容器能在编译期能实现这些操作, 是因为使用了瞬态分配 : 编译期申请的内存必须在编译期就释放, 不能将编译期申请的内存在运行时使用 因为没有应用新的 , 所以需要像下面这样做 C++ 20 之后 其他容器也类似可以方便的判断容器是否包含一个元素 比较长,并且对初学者不友好 这样就非常的简单了std::shift_left, std::shift_right - C++中文 - API参考文档 (apir
sarscape 将dem文件转化成stl_何为 STL——论 C++20 中 SGI STL 的派生
weixin_39992831的博客
11-11 107
前言C++ 标准库中有被称为 STL （常被视为标准模板库， standard template library 的缩写）的组件。其外延往往是不统一的：最广的可见于 microsoft/STL ——指代 C++ 标准库中来自 C 标准库以外的部分。最狭义的看法可能认为 string 不属于 STL ——因为尽管现在它是 basic_string 的特化，但它在 C++ 有模板之前就出现了。这里，我...
C++学习20：容器深度探索之vector源码剖析
时间有泪
05-25 1010
简单地说，vector就是一种可以动态增长的数组。 1 vector源码 图中，start和finish为begin和end迭代器所指向的位置，size为已填充元素的大小，capacity为目前vector的总容量，end_of_storage为能填到的最后一个元素位置。当超过end_of_storage时，在内存中找到一个达到两倍大原空间的内存空间进行填充操作。源码如下： 可见，数据中只有s...
C++20学习：concept用法介绍
追风筝的人的专栏
01-17 1526
概述 众所周知，C++的泛型强大，很多语言都学了，比如C#、Java，虽然Java的泛型只是语法糖，不值得一提。 C++的template实际上是创造了一种新的语言，这个语言是编译期的，相当于编译器把代码解释成C++语言，然后再编译成机器指令。STL的诞生，是颠覆性的创举，然而STL所用到的泛型还只是C++template中其中一部分特性。 C++使用template实现泛型算法，我们来看下一个简单的例子。 template<typename T> T inc(T a) { return
深入解析C++ STL中的常用容器
12-31
STL中的常用容器包括：顺序性容器（vector、deque、list）、关联容器（map、set）、容器适配器（queue、stac）。 1、顺序性容器 （1）vectorvector是一种动态数组，在内存中具有连续的存储空间，支持快速随机访问。...
C++20学习笔记——智能指针
XXTongC的博客
04-25 150
智能指针就是帮我们C++程序员管理动态分配的内存的，它会帮助我们自动释放new出来的内存，从而避免内存泄漏！记住添加 memory模块。
C++基础知识整理二十（STL算法）
一行一生
11-20 205
1，STL算法一 2，STL算法二
C++ 20标准入门学习笔记
weixin_43830176的博客
05-15 278
个人学习笔记
C++（20）：STL初步之set初步
qcyfred的博客
12-26 463
STL的set的简单用法。
C++学习 二十、STL（3）序列容器
qq_41035283的博客
03-15 1693
C++学习 二十、STL（3）序列容器前言序列容器类型序列容器方法 前言 本篇继续学习C++中的STL，序列容器。 序列容器类型 序列容器，一般是通过类似数组的形式，按照次序存储某种类型的数据，包括： array<T, N>数组容器，类似于普通数组，存储N个T类型的数据，不能增加或者减少元素，只能修改元素的值。 vector<T>向量容器，长度可变，当内存不足时会自动申请分配新内存。可以在尾部高效增加或者删除元素，也可以在任意位置低效插入和删除元素。 deque<T>双
C++20 实践入门（第6版）
Codyliu_lq的博客
03-21 267
要说对比之前的版本有啥区别，C++20做了一些针对高级应用的扩展。这本书希望读者学完后能够掌握C++并且享受C++编程，与诸君共勉。此系列博文主要记录了我学习这本书的过程，因此后续会不断增加内容。本书讲解的C++语言对应最新的国际标准，常被称为C++20。如果你也和我一样是编程小白的话，那就去学习吧！
2021-03-23-C++学习之20-STL-常用算法
weixin_42656213的博客
03-23 122
一、常用遍历算法 二、常用查找算法 三、常用排序算法 四、常用拷贝和替换算法 五、常用算术生成算法 六、常用集合算法
C++学习 二十、STL（4）pair类型, tuple类型
qq_41035283的博客
03-17 1051
C++学习 二十、STL（4）关联容器前言pairtuple 前言 本篇继续学习C++，STL的关联容器类型。 pair pair类型在utility头文件中，用于把两个数据组成一对，使用pair就能让函数间接返回两个值。C++中的pair类似于python中的[a, b]。 可以通过构造函数或者utility头文件中的make_pair函数创建pair对象，可以直接访问pair对象的first, second成员，也可以使用>,<,=比较同类型的pair对象。（首先比较first成员，如果相等
C++学习笔记_20 适配器容器-priority_queue 2021-05-19
lybc2019的博客
05-19 188
priority_queue 优先级队列 插入容器内的数据，按降序排列方式被取出 -最先取出的数据，是队列中，值最大的那个 // C++学习笔记_20 适配器容器- priority_queue // #include<iostream> #include<string> #include<queue> using namespace std; class AAA { private: int x; int y; public: AAA().
C++学习笔记20——顺序容器的操作
孤独的根号3的博客
10-31 349
总结：vector容器只能对其尾部的元素进行快速的增加和删除，除了insert()操作，其他对容器前端的操作都对其不适用。              list容器不能随机读写，所以没有下标操作              deque的操作最全。              使用一对迭代器的操作，总是包括开头，不包括结尾[b, e)
探索《C++ 20 STL Cookbook》：提高你的C++编程效率
最新发布
gitblog_00082的博客
04-01 681
探索《C++ 20 STL Cookbook》：提高你的C++编程效率 CPP-20-STL-Cookbook《C++20 STL Cookbook》的非专业个人翻译项目地址:https://gitcode.com/gh_mirrors/cpp/CPP-20-STL-Cookbook 项目简介 在编程世界中，C++以其高效、灵活性和丰富的库支持成为许多专业开发者的选择。而Standard Tem...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值