STL常见容器
string容器
string的基本概念
本质:
string是c++的风格的字符串,而string本质上是一个类
string和char*的区别:
char* 是一个指针
string是一个类,类内部封装了char*,管理这个字符串的是一个char*型的容器
特点:
- string内部封装了很多成员方法
- string管理char*所分配的内存,不用担心复制越界和取值越界等,由类内部负责
string构造函数
- string();
- string (const char *s);
- string (const string& str);
- 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的赋值操作
- sting& operator=(const chars); --------char字符串赋值给当前字符串
- sting& operator=(const string &s); --------把字符串s赋值给当前字符串
- sting& operator=(const char c); --------字符c赋值给当前字符串
- sting& assign(const char*s); --------把字符串s赋值给当前字符串
- sting& assign(const char*s,int n); --------把字符串s的前n个字符赋值给当前字符串
- sting& assign(const string &s); --------把字符串s赋值给当前字符串
- 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;
}
字符串拼接
实现在字符串末尾拼接字符串
函数原型
运算符+=重载:
- sting& operator+=(const char* str);
- sting& operator+=(const string &s);
- sting& operator+=(const char c);
append方法: - sting& appendconst char*s); --------把字符串s连接到当前字符串结尾
- sting& append(const char*s,int n); --------把字符串s的前n个字符连接到当前字符串结尾
- sting& append(const string &s); --------相当于operator+=(const string &s);
- 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;
}
字符串查找和替换
查找:查找指定的字符串是否存在
替换:在指定的位置替换字符串
函数原型
- int find(const string& str,int pos=0) const; //查找str第一次出现的位置,从pos开始查找
- int find(const char* s,int pos=0) const; //查找s第一次出现的位置,从pos开始查找
- int find(const char* s,int pos=0,int n) const; //从pos开始查找s的前n个字符第一次出现的位置
- int find(const char c) const; //查找字符c第一次出现的位置
- int rfind(const string& str,int pos=npos) const; //查找str最后一次出现的位置,从pos开始查找
- int rfind(const char* s,int pos=npos) const; //查找s最后一次出现的位置,从pos开始查找
- int rfind(const char* s,int pos=npos,int n) const; //从pos开始查找s的前n个字符最后一次出现的位置
- int rfind(const char c) const; //查找字符c最后一次出现的位置
- string &replace(int pos,int n,const string &str);替换从pos开始的n个字符为字符串str
- 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
函数原型
- int compare(const string &str) const; //与字符串str进行比较
- 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字符存取
- char& operator[](int n) //通过[]取字符串
- 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插入与删除
函数原型
- string& insert(int pos,const char *s); //插入字符串
- string& insert(int pos,const string& str); //插入字符串
- string& insert(int pos,int n,char c);//在指定位置pos插入n个字符c
- 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构造容器
函数原型:
- vector v; //采用模板实现类实现,默认构造函数
- vector(v.begin() , v.end()); //将**v[begin(),end())**区间中的元素拷贝给本身
- vector(n,elem); //构造函数将n个elem拷贝给本身
- 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赋值操作
函数原型
- vector& operator=(const vector &vec); //重载等号操作符
- assign(beg,end); //将[beg,end)区间中的数据拷贝赋值给本身
- 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容量和大小
函数原型:
- empty(); //判断容器是否为空
- capacity(); //容器的容量
- size(); //返回容器中元素的个数
- resize(int num ); //重新指定容器的长度为num,若容器变长,则以默认值填充新位置;如果容器变短,则末尾超出容器长度的元素要被删除
- 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插入和删除
函数原型
- push_back(ele); //尾部插入元素ele
- pop_back(); //删除最后一个元素
- insert(const_iterator pos,ele); //迭代器指向位置pos插入元素ele
- insert(const_iterator pos,int cout,els); //迭代器指向位置pos插入cout个元素ele
- erase(const_iterator pos); //删除迭代器指向的元素
- erase(const_iterator start,const_iterator end); //删除迭代器start到end之间的元素
- 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数据存取
函数原型
- at(int idx); //返回索引idx所指的数据
- operator[ int idx ]; //返回索引idx所指的数据
- front(); //返回容器的第一个元素
- 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赋值
函数原型
- deque& operator=(const vector &vec); //重载等号操作符
- assign(beg,end); //将[beg,end)区间中的数据拷贝赋值给本身
- 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个评委分别对每一个选手打分,去除最高分和最低分,取平均分
实现步骤
- 创建五名选手,放到vector中
- 遍历vector容器,取出来每一个选手,执行for循环,可以把10个评分打分存到deque容器中
- sort算法对deque容器中分数进行排序,去除最高分和最低分
- deque容器再遍历一遍,累加总分
- 获取平均分
注:同学习视频有部分不同,主要体现在遍历的方式,大致相同,实现的效果也是相同的
#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;
}