1、string容器
1.1、string基本概念
本质:
- string是C++风格的字符串,而string本质上是一个类
string和char * 区别:
- char * 是一个指针
- string是一个类,类内部封装了char*,管理这个字符串,是一个char*型的容器。
特点:
string 类内部封装了很多成员方法
例如:查找find,拷贝copy,删除delete 替换replace,插入insert
string管理char*所分配的内存,不用担心复制越界和取值越界等,由类内部进行负责
1.2、string构造函数
构造函数原型:
string();
//创建一个空的字符串 例如: string str;string(const char* s);
//使用字符串s初始化string(const string& str);
//使用一个string对象初始化另一个string对象string(int n, char c);
//使用n个字符c初始化
示例:
#include <iostream>
using namespace std;
#include <string>
//string构造函数
//● string(); //创建一个空的字符串 例如: string str;
//● string(const char* s); //使用字符串s初始化
//● string(const string& str); //使用一个string对象初始化另一个string对象
//● string(int n, char c); //使用n个字符c初始化
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 0;
}
总结:string有多种构造方式,没有可比性,灵活使用即可
1.3、string赋值操作
功能描述:
- 给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>
using namespace std;
#include <string>
//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 test01()
{
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);
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 0;
}
总结:string赋值的方式有很多,operator=
这种方式是比较实用的。
1.4、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 &s);
//同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& s); //同operator+=(const string& str)
//● string& append(const string& s, int pos, int n);//字符串s中从pos开始的n个字符连接到字符串结尾
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 ");
cout << "str3 = " << str3 << endl;
str3.append("game abcde", 4);
cout << "str3 = " << str3 << endl;
str3.append(str2);
cout << "str3 = " << str3 << endl;
str3.append(str2, 4, 3);
cout << "str3 = " << str3 << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结:字符串拼接的重载版本很多,初学阶段记住几个即可
1.5、string查找和替换
功能描述:
- 查找:查找指定字符串是否存在
- 替换:在指定的位置替换字符串
函数原型:
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, int n) const;
//从pos位置查找s的前n个字符第一次位置int find(const char c, int pos = 0) 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, int n) const;
//从pos查找s的前n个字符最后一次位置int rfind(const char c, int pos = 0) const;
//查找字符c最后一次出现位置string& replace(int pos, int n, const string& str);
//替换从pos开始n个字符为字符串strstring& replace(int pos, int n,const char* s);
//替换从pos开始的n个字符为字符串s
示例:
#include <iostream>
using namespace std;
//string查找和替换
//● 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, int n) const; //从pos位置查找s的前n个字符第一次位置
//● int find(const char c, int pos = 0) 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, int n) const; //从pos查找s的前n个字符最后一次位置
//● int rfind(const char c, int pos = 0) 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
//1、查找
void test01()
{
string str1 = "abcdefg";
int pos = str1.find("de");
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 str1 = "abcdefg";
//从1号位置起,3个字符,替换为1111
str1.replace(1, 3, "1111");
cout << "str1 = " << str1 << endl;
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
总结:
- find查找是从左往后,rfind从右往左,pos均为0
- find找到字符串后返回查找的第一个字符位置,找不到返回-1
- replace在替换时,要指定从哪个位置起,多少个字符,替换成什么样的字符串,指定的字符都会被替换过去
1.6、string字符串比较
功能描述:
- 字符串之间的比较
比较方式:
- 字符串比较是按字符的ASCII码进行对比
= 返回 0
> 返回 1
< 返回 -1
函数原型:
int compare(const string &s) const;
//与字符串s比较int compare(const char *s) const;
//与字符串s比较
示例:
#include <iostream>
#include <string>
using namespace std;
//string字符串比较
void test01()
{
string str1 = "xello";
string str2 = "hello";
if (str1.compare(str2) == 0)
{
cout << "str1等于str2" << endl;
}
else if(str1.compare(str2)>0)
{
cout << "str1大于str2" << endl;
}
else
{
cout << "str1小于str2" << endl;
}
}
int main()
{
test01();
system("pause");
return 0;
}
总结:字符串之间的比较是通过对逐个字符串进行AISCII码的比较,并且主要是比较两个字符串是否相等,判断谁大谁小的意义不是很大
1.7、string字符存取
string中单个字符存取方式有两种
- char& operator[](int n); //通过[]方式取字符
- char& at(int n); //通过at方法获取字符
示例:
#include <iostream>
#include <string>
using namespace std;
//string字符存取
void test01()
{
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] = 'x';
//xello
cout << "str = " << str << endl;
str.at(1) = 'x';
//xxelo
cout << "str = " << str << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
1、string字符串中单个字符存取有两种方式,利用str[i]
或str.at(i)
2、我们同样可以通过这两种方式对字符串中某一个字符进行改变
拓展:字符串中的size函数可以得到字符串的大小:str.size()
1.8、string插入和删除
功能描述:
对string字符串进行插入和删除字符操作
函数原型:
string& insert(int pos, const char* s);
//插入字符串string& insert(int pos, const string& str);
//插入字符串string& insert(int pos, int n, char c);
//在指定位置插入n个字符cstring& erase(int pos, int n = npos);
//删除从Pos开始的n个字符
示例:
#include <iostream>
#include <string>
using namespace std;
//字符串 插入和删除
void test01()
{
string str = "Hello";
//插入
str.insert(1, "111");
//h111ello
cout << "str = " << str << endl;
//删除
str.erase(1, 3);
cout << "str = " << str << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结:字符串的插入和删除的起始下标都是从0开始
1.9、string子串
功能描述:
- 从字符串中获取想要的子串
函数原型:
- string substr(int pos = 0, int n = npos) const; //返回由pos开始的n个字符组成的字符串
示例:
#include <iostream>
#include <string>
using namespace std;
//string求子串
void test01()
{
string str = "abcdef";
string subStr = str.substr(1, 3);
cout << "subStr = " << subStr << endl;
}
//实用操作
void test02()
{
string email = "[email protected]";
//从邮件地址获取qq号
int pos = email.find("@");
string QQ = email.substr(0, pos);
cout << "QQ = " << QQ << endl;
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
总结:灵活运用求子串功能,可以在实际开发中获取有效的信息
2、Vector容器
2.1、vector基本概念
功能:
- vector数据结构和数组非常相似,也称为单端数组
vector与普通数组区别:
- 不同之处在于数组是静态空间,而vector可以动态扩展
一般的数组确定范围后不可以改变,而vector容器内存容量可以动态扩展
动态扩展:
- 并不是在原空间之后续接新空间,而是找更大的内存空间,然后将原数据拷贝新空间,释放原空间
- vector容器的迭代器是支持随机访问的迭代器
2.2、vector构造函数
功能描述:
- 创建vector容器
函数原型:
vector<T> 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>
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);
//通过区间方式进行构造
vector<int> v2(v1.begin(), v1.end());
printVector(v2);
//n个elem方式构造
vector<int> v3(10, 100);
printVector(v3);
//拷贝构造(常用)
vector<int> v4(v3);
printVector(v4);
}
int main()
{
test01();
system("pause");
return 0;
}
总结:vector的多种构造方式没有可比性,灵活使用即可
1、默认构造,无参构造
2、把另一个vector容器中的区间元素拷贝过来
3、拷贝n(第一个参数)个elem(第二个参数)作为元素
4、把另一个vector完全拷贝构造过来
2.3、vector赋值操作
功能描述:
- 给vector容器进行赋值
函数原型:
- vector& operator=(const vector &vec);//重载等号操作符
- assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
- assign(n, elem); //将n个elem拷贝赋值给本身。
示例:
#include <iostream>
using namespace std;
#include <vector>
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 0;
}
总结:vector赋值方式比较简单,使用operator=,或者assign都可以
2.4、vector容量和大小
功能描述:
- 对vector容器的容量和大小操作
函数原型:
empty();
//判断容器是否为空capacity();
//容器的容量size();
//返回容器中元素的个数resize(int num);
//重新指定容器的长度为num,若容器变长,则以默认值0填充新位置。
//如果容器变短,则末尾超出容器长度的元素被删除。
resize(int num, elem);
//重新指定容器的长度为num,若容器变长,则以elem值填充新位置。
//如果容器变短,则末尾超出容器长度的元素被删除
示例:
#include <iostream>
using namespace std;
#include <vector>
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);//利用重载版本,可以指定默认填充值,参数2
printVector(v1);//如果重新指定的比原来长了,默认用0填充新的位置
v1.resize(5);
printVector(v1);
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
- 判断是否为空 — empty
- 返回元素个数 — size
- 返回容器容量 — capacity
- 重新指定大小 — resize
2.5、vector插入和删除
功能描述:
- 对vector容器进行插入、删除操作
函数原型:
push_back(ele);
//尾部插入元素elepop_back();
//删除最后一个元素insert(const_iterator pos, ele);
//迭代器指向位置pos插入元素eleinsert(const_iterator pos, int count,ele);
//迭代器指向位置pos插入count个元素eleerase(const_iterator pos);
//删除迭代器指向的元素erase(const_iterator start, const_iterator end);
//删除迭代器从start到end之间的元素clear();
//删除容器中所有元素
示例:
#include <iostream>
using namespace std;
#include <vector>
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 0;
}
总结:
- 尾插---------push_back
- 尾删---------pop_back
- 插入---------insert(位置迭代器)
- 删除---------erase(位置迭代器)
- 清空---------clear
2.6、vector数据存取
功能描述:
- 对vector中的数据的存取操作
函数原型:
- at(int idx); //返回索引idx所指的数据
- operator[]; //返回索引idx所指的数据
- front(); //返回容器中第一个数据元素
- back(); //返回容器中最后一个数据元素
示例:
#include <iostream>
using namespace std;
#include <vector>
//vector容器 数据存取
//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 0;
}
总结:
- 除了用迭代器获取vector容器中元素,[]和at也可以
- front返回容器第一个元素
- back返回容器最后一个元素
2.7、vector互换容器
功能描述:
- 实现两个容器内元素进行互换
函数原型:
- swap(vec); // 将vec与本身的元素互换
示例:
#include <iostream>
using namespace std;
#include <vector>
//vector容器互换
void printVector(vector<int>& v)
{
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//vector容器的容量和大小
void test01()
{
cout << "交换前:" << endl;
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
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).swap(v);
cout << "v的容量为:" << v.capacity() << endl;
cout << "v的大小为:" << v.size() << endl;
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
总结:
swap可以使两个容器互换,可以达到实用的收缩内存效果
利用匿名对象和原来的容器进行交换,再利用匿名对象使用后自动释放的特性解决浪费的空间。
2.8、预留空间
功能描述:
- 减少vector在动态扩展容量时的扩展次数
函数原型:
- reserve(int len);//容器预留len个元素长度,预留位置不初始化,元素不可访问。
示例:
#include <iostream>
using namespace std;
#include <vector>
//vector容器 预留空间
void printVector(vector<int>& v)
{
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
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;
}
int main()
{
test01();
system("pause");
return 0;
}
总结:如果数据量较大,可以一开始利用reserve预留空间,避免重复开辟内存
3、deque容器
3.1、deque容器的基本概念
功能:
- 双端数组,可以对头端进行插入删除操作
deque与vector区别:
- vector对于头部的插入删除效率低,数据量越大,效率越低
- deque相对而言,对头部的插入删除速度回比vector快
- vector访问元素时的速度会比deque快,这和两者内部实现有关
deque内部工作原理:
deque内部有个中控器,维护每段缓冲区中的内容,缓冲区中存放真实数据
中控器维护的是每个缓冲区的地址,使得使用deque时像一片连续的内存空间
deque容器的迭代器也是支持随机访问的
deque容器的插入元素速度比vector快,是因为他可以直接往前面或者后面的缓冲区插入数据,然后再给出指向这些数据的地址并存储在中控器中。
deque容器访问元素的速度比vector慢,是因为他在访问完一个缓冲区后,需要先找到下一个缓冲区的地址,再通过地址去访问其缓冲区中数据。
3.2、deque构造函数
功能描述:
- deque容器构造
函数原型:
- deque<T> deqT; //默认构造形式
- deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。
- deque(n, elem); //构造函数将n个elem拷贝给本身。
- deque(const deque &deq); //拷贝构造函数
示例:
#include <iostream>
using namespace std;
#include <deque>
//deque容器 构造函数
void printDeque(const deque<int>& d)//只允许对deque中的数据只读
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
{
//*it = 100;//容器中的数据不可以修改了
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());//构造函数将【begin,end】中的元素拷贝给本身
printDeque(d2);
deque<int>d3(10, 100);//把10个100拷贝给d3
printDeque(d3);
deque<int>d4(d3);//拷贝构造函数
printDeque(d4);
}
int main()
{
test01();
system("pause");
return 0;
}
总结:deque容器和vector容器的构造方式基本相同,灵活使用即可
扩展:如果在输出deque容器数据时,只进行只读操作,那么就可以在输出函数的参数中加入const
,并且把迭代器改为常量迭代器const_iterator
3.3、deque赋值操作
功能描述:
- 给deque容器进行赋值
函数原型:
- deque& operator=(const deque &deq); //重载等号操作符
- assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
- assign(n, elem); //将n个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);
//operator=赋值
deque<int>d2 = d1;//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 0;
}
总结:deque赋值操作也与vector相同,需熟练掌握
3.4、deque大小操作
功能描述:
- 对deque容器的大小进行操作
函数原型:
deque.empty();
//判断容器是否为空deque.size();
//返回容器中元素的个数deque.resize(num);
//重新指定容器的长度为num,若容器变长,则以默认值填充新位置。//如果容器变短,则末尾超出容器长度的元素被删除。deque.resize(num, elem);
//重新指定容器的长度为num,若容器变长,则以elem值填充新位置。//如果容器变短,则末尾超出容器长度的元素被删除。
示例:
#include <iostream>
using namespace std;
#include <deque>
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);
//判断容器是否为空
if (d1.empty()) {
cout << "d1为空!" << endl;
}
else {
cout << "d1不为空!" << endl;
//统计大小
cout << "d1的大小为:" << d1.size() << endl;
}
//重新指定大小
d1.resize(15, 1);
printDeque(d1);
d1.resize(5);
printDeque(d1);
}
int main() {
test01();
system("pause");
return 0;
}
总结:
- deque没有容量的概念——有无限容量
- 判断是否为空——empty
- 返回元素个数——size
- 重新指定个数——resize
若容器变长,默认用0填充,也可以自己指定;
若容器变短,直接删除后面的数据即可
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位置的数据,返回下一个数据的位置。
示例:
#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> d;
//尾插
d.push_back(10);
d.push_back(20);
//头插
d.push_front(100);
d.push_front(200);
//200 100 10 20
printDeque(d);
//尾删
d.pop_back();
//头删
d.pop_front();
//100 10
printDeque(d);
}
//插入
void test02()
{
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);
printDeque(d);
d.insert(d.begin(), 1000);
//1000 200 100 10 20
printDeque(d);
d.insert(d.begin(), 2, 10000);
//10000 10000 ~
printDeque(d);
deque<int>d2;
d2.push_back(1);
d2.push_back(2);
d2.push_back(3);
d.insert(d.begin(), d2.begin(), d2.end());
printDeque(d);
}
//删除
void test03()
{
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);
printDeque(d);
d.erase(d.begin());
printDeque(d);
d.erase(d.begin(), d.end());
d.clear();
printDeque(d);
}
int main() {
//test01();
//test02();
test03();
system("pause");
return 0;
}
总结:
- 插入和删除提供位置的是迭代器
- 尾插-----push_back
- 尾删-----pop_back
- 头插-----push_front
- 头删-----pop_front
3.6、deque数据存取
功能描述:
- 对deque 中的数据的存取操作
函数原型:
- at(int idx); //返回索引idx所指的数据
- operator[]; //返回索引idx所指的数据
- front(); //返回容器中第一个数据元素
- back(); //返回容器中最后一个数据元素
示例:
#include <iostream>
using namespace std;
#include <deque>
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_front(100);
d.push_front(200);
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 << "front:" << d.front() << endl;
cout << "back:" << d.back() << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结:
- 除了用迭代器获取deque容器中元素,[]和at也可以
- front返回容器中第一个元素
- back返回容器中最后一个元素
3.7、deque排序
功能描述:
- 利用算法实现对deque容器进行排序
算法:
- sort(iterator beg, iterator end) //对beg和end区间内元素进行排序
示例:
#include <iostream>
using namespace std;
#include <deque>
#include <algorithm>//标准算法头文件
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> d;
d.push_back(10);
d.push_back(20);
d.push_back(300);
d.push_front(100);
d.push_front(200);
d.push_front(300);
printDeque(d);
//排序 默认从小到大
//对于利用支持随机访问的迭代器的容器,都可以利用sort算法直接对其进行排序
//vector容器也可以利用sort进行排序
sort(d.begin(), d.end());
cout << "排序后:" << endl;
printDeque(d);
}
int main() {
test01();
system("pause");
return 0;
}
总结:sort算法非常实用,使用时包含头文件algorithm即可
4、案例——评委打分
4.1、案例描述
有5名选手:选手ABCDE,10个评委分别对每一名选手打分,去除最高分,去除评委中最低分,取平均分。
4.2、实现步骤
- 创建五名选手,放到vector中
- 遍历vector容器,取出来每一个选手,执行for循环,可以把10个评分打分存到deque容器中
- sort算法对deque容器中分数排序,去除最高和最低分
- deque容器遍历一遍,累加总分
- 获取平均分
示例:
5、stack容器(栈)
5.1、stack容器基本概念
概念:*stack是一种*先进后出(First In Last Out,FILO)的数据结构,它只有一个出口
栈中只有顶端的元素才可以被外界使用,因此栈不允许有遍历行为
栈可以判断容器是否为空码?——可以empty
栈可以返回元素个数吗?——可以size
栈中进入数据称为 — 入栈 push
栈中弹出数据称为 — 出栈 pop
生活中的栈:
5.2、stack常用接口
功能描述:栈容器常用的对外接口
构造函数:
- stack<T> stk; //stack采用模板类实现, stack对象的默认构造形式
- stack(const stack &stk); //拷贝构造函数
赋值操作:
- stack& operator=(const stack &stk); //重载等号操作符
数据存取:
- push(elem); //向栈顶添加元素
- pop(); //从栈顶移除第一个元素
- top(); //返回栈顶元素
大小操作:
- empty(); //判断堆栈是否为空
- size(); //返回栈的大小
示例:
#include <iostream>
using namespace std;
#include <stack>
//栈stack容器 常用接口
void test01()
{
//特点:符合先进后出数据结构
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;
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
- 入栈-----push
- 出栈-----pop
- 返回栈顶-----top
- 判断栈是否为空-----empty
- 返回栈大小-----size
6、queue容器(队列)
6.1、queue基本概念
概念:*Queue是一种*先进先出(First In First Out,FIFO)的数据结构,它有两个出口
队列容器允许从一端新增元素,从另一端移除元素
队列中只有队头和队尾才可以被外界使用,因此队列不允许有遍历行为
可以判断容器是否为空码?——可以empty
可以返回元素个数吗?——可以size
队列中进数据称为 — 入队 push
队列中出数据称为 — 出队 pop
生活中的队列:
6.2、queue常用接口
功能描述:栈容器常用的对外接口
构造函数:
- queue<T> que; //queue采用模板类实现,queue对象的默认构造形式
- queue(const queue &que); //拷贝构造函数
赋值操作:
- queue& operator=(const queue &que); //重载等号操作符
数据存取:
- push(elem); //往队尾添加元素
- pop(); //从队头移除第一个元素
- back(); //返回最后一个元素
- front(); //返回第一个元素
大小操作:
- empty(); //判断堆栈是否为空
- size(); //返回栈的大小
示例:
#include <iostream>
using namespace std;
#include <queue>
#include <string>
//队列 queue
class Person
{
public:
Person(string name, int age)
{
m_Name = name;
m_Age = age;
}
string m_Name;
int m_Age;
};
void test01()
{
//创建队列
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;
}
int main()
{
test01();
system("pause");
return 0;
}
7、list容器(链表)
7.1、list基本概念
功能:**将数据进行链式存储
链表(list)是一种物理存储单元上非连续的存储结构,数据元素的逻辑顺序是通过链表中的指针链接实现的
链表的组成:链表由一系列结点组成
结点的组成:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域
STL中的链表是一个双向循环链表
由于链表的存储方式并不是连续的内存空间,因此链表list中的迭代器只支持前移和后移,属于双向迭代器
list的优点:
- 采用动态存储分配,不会造成内存浪费和溢出(容量等于大小)
- 链表执行插入和删除操作十分方便,修改指针即可,不需要移动大量元素
list的缺点:
- 链表灵活,但是空间(指针域) 和 时间(遍历)额外耗费较大
List有一个重要的性质,插入操作和删除操作都不会造成原有list迭代器的失效,这在vector是不成立的。
总结:STL中List和vector是两个最常被使用的容器,各有优缺点
7.2、list构造函数
功能描述:
- 创建list容器
函数原型:
list<T> lst;
//list采用采用模板类实现,对象的默认构造形式:list(beg,end);
//构造函数将[beg, end)区间中的元素拷贝给本身。list(n,elem);
//构造函数将n个elem拷贝给本身。list(const list &lst);
//拷贝构造函数。
示例:
#include <iostream>
using namespace std;
#include <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 test01()
{
//创建list容器
list<int>L1;//默认构造
//添加数据
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
//遍历容器
printList(L1);
//区间方式构造
list<int>L2(L1.begin(), L1.end());
printList(L2);
//拷贝构造
list<int>L3(L2);//=L2;
printList(L3);
//n个elem
list<int>L4(10, 1000);
printList(L4);
}
int main()
{
test01();
system("pause");
return 0;
}
总结:list构造方式和其他几个STL常用容器相同,熟练掌握即可
7.3、list赋值和交换
功能描述:
- 给list容器进行赋值,以及交换list容器
函数原型:
assign(beg, end);
//将[beg, end)区间中的数据拷贝赋值给本身。assign(n, elem);
//将n个elem拷贝赋值给本身。list& operator=(const list &lst);
//重载等号操作符swap(lst);
//将lst与本身的元素互换。
示例:
#include <iostream>
using namespace std;
#include <list>
void printList(const list<int>& L) {
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//list容器 赋值和交换
void test01()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printList(L1);
//赋值
list<int>L2;
L2 = L1;//operator=赋值
printList(L2);
list<int>L3;
L3.assign(L2.begin(), L2.end());
printList(L3);
list<int>L4;
L4.assign(10, 100);
printList(L4);
}
//交换
void test02()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
list<int>L2;
L2.assign(10, 100);
cout << "交换前: " << endl;
printList(L1);
printList(L2);
cout << endl;
//交换函数
L1.swap(L2);
cout << "交换后: " << endl;
printList(L1);
printList(L2);
}
int main() {
//test01();
test02();
system("pause");
return 0;
}
总结:list赋值和交换操作能够灵活运用即可
7.4、list大小操作
功能描述:
- 对list容器的大小进行操作
函数原型:
size();
//返回容器中元素的个数empty();
//判断容器是否为空resize(num);
//重新指定容器的长度为num,若容器变长,则以默认值0填充新位置。
//如果容器变短,则末尾超出容器长度的元素被删除。
resize(num, elem);
//重新指定容器的长度为num,若容器变长,则以elem值填充新位置。
//如果容器变短,则末尾超出容器长度的元素被删除。
示例:
#include <iostream>
using namespace std;
#include <list>
void printList(const list<int>& L) {
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//list容器 大小操作
void test01()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
//判断容器是否为空
if (L1.empty())
{
cout << "L1为空" << endl;
}
else
{
cout << "L1不为空" << endl;
cout << "L1的大小为: " << L1.size() << endl;
}
//重新指定大小
L1.resize(10);
printList(L1);
L1.resize(2);
printList(L1);
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
- 判断是否为空——empty
- 返回元素个数——size
- 重新指定个数——resize
7.5、list插入和删除
功能描述:
- 对list容器进行数据的插入和删除
函数原型:
push_back(elem);
//在容器尾部加入一个元素pop_back();
//删除容器中最后一个元素push_front(elem);
//在容器开头插入一个元素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位置的数据,返回下一个数据的位置。remove(elem);
//删除容器中所有与elem值匹配的元素。
示例:
#include <iostream>
using namespace std;
#include <list>
void printList(const list<int>& L) {
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//list容器 插入和删除
void test01()
{
list<int> L;
//尾插
L.push_back(10);
L.push_back(20);
L.push_back(30);
//头插
L.push_front(100);
L.push_front(200);
L.push_front(300);
printList(L);
//尾删
L.pop_back();
printList(L);
//头删
L.pop_front();
printList(L);
//插入
list<int>::iterator it = L.begin();
L.insert(++it, 1000);
printList(L);
//删除
it = L.begin();
L.erase(++it);
printList(L);
//移除
L.push_back(10000);
L.push_back(10000);
L.push_back(10000);
printList(L);
L.remove(10000);
printList(L);
//清空
L.clear();
printList(L);
}
int main() {
test01();
system("pause");
return 0;
}
总结:
- 尾插——push_back
- 尾删——pop_back
- 头插——push_front
- 头删——pop_front
- 插入——insert(需要迭代器)
- 删除——erase(需要迭代器)
- 移除——remove(删除所有匹配数据)
- 清空——clear
7.6、list数据存取
功能描述:
- 对list容器中数据进行存取
函数原型:
- front(); //返回第一个元素。
- back(); //返回最后一个元素。
示例:
#include <iostream>
using namespace std;
#include <list>
//数据存取
void test01()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
//cout << L1.at(0) << endl;//错误 不支持at访问数据
//cout << L1[0] << endl; //错误 不支持[]方式访问数据
//原因是list是本质链表,不是用连续线性空间存储数据,迭代器也是不支持随机访问的
cout << "第一个元素为: " << L1.front() << endl;
cout << "最后一个元素为: " << L1.back() << endl;
//list容器的迭代器是双向迭代器,不支持随机访问
list<int>::iterator it = L1.begin();
it++;
//it = it + 1;//错误,不可以跳跃访问,即使是+1
}
int main() {
test01();
system("pause");
return 0;
}
总结:
- list容器不可以通过[]和at方式访问数据
- 返回第一个元素——front
- 返回最后一个元素——back
7.7、list反转和排序
功能描述:
- 将容器中的元素反转,以及将容器中的数据进行排序
函数原型:
- reverse(); //反转链表
- sort(); //链表排序
示例:
#include <iostream>
using namespace std;
#include <list>
//#include <algorithm>
void printList(const list<int>& L) {
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
bool myCompare(int val1, int val2)
{
//降序,就让第一个数 > 第二个数
return val1 > val2;
}
//list容器 反转和排序
void test01()
{
list<int> L;
L.push_back(90);
L.push_back(30);
L.push_back(20);
L.push_back(70);
cout << "反转前:" << endl;
printList(L);
//反转容器的元素
L.reverse();
cout << "反转后:" << endl;
printList(L);
//排序
//所有不支持随机访问迭代器的容器,不可以用标准算法
// 不支持随机迭代器访问的容器,内部会提供对应的一些算法
//sort(L.begin(), L.end());
L.sort(); //默认的排序规则 从小到大
cout << "从小到大:";
printList(L);
L.sort(myCompare); //指定规则,从大到小
cout << "从大到小:";
printList(L);
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
- 反转——reverse
反转在使用时直接调用对象.reverse()
即可
- 排序——sort(成员函数)
所有不支持随机访问迭代器的容器,不可以用标准算法库,但是其内部会提供一些内置算法
提供一个函数作为排序的参数,通过重载函数实现从大到小排序
7.8、排序案例
案例描述:将Person自定义数据类型进行排序,Person中属性有姓名、年龄、身高
排序规则:按照年龄进行升序,如果年龄相同按照身高进行降序
示例:
#include <iostream>
using namespace std;
#include <string>
#include <list>
//list容器-排序案例,对于自定义数据类型做排序
//按照年龄进行升序,如果年龄相同按照身高进行降序
class Person
{
public:
Person(string name, int age, int height)
{
m_Name = name;
m_Age = age;
m_Height = height;
}
string m_Name;
int m_Age;
int m_Height;
};
//输出函数
void printPerson(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 << endl;
}
cout << endl;
}
//指定排序规则
bool comparePerson(Person& p1, Person& p2)
{
//按照年龄 升序
if (p1.m_Age == p2.m_Age)
{
//年龄相同,按身高降序
return p1.m_Height > p2.m_Height;
}
else
{
return p1.m_Age < p2.m_Age;
}
}
void test01()
{
list<Person>L;//创建容器
//准备数据
Person p1("刘备", 35, 175);
Person p2("曹操", 45, 180);
Person p3("孙权", 40, 170);
Person p4("赵云", 25, 190);
Person p5("张飞", 35, 160);
Person p6("关羽", 35, 200);
//插入数据
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;
printPerson(L);
//排序
cout << "-----------------------------" << endl;
cout << "排序后:" << endl;
L.sort(comparePerson);
printPerson(L);
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
- 对于自定义数据类型,必须指定排序规则,否则编译器不知道如何进行排序
- 高级排序只是在排序规则上再进行一次逻辑规则指定,并不复杂
我们利用仿函数的形式,将sort函数参数定为一个具有复杂排序规则的函数
8、set/multiset容器(集合)
8.1、set基本概念
简介:
- 所有元素都会在插入时自动被排序
本质:
- set/multiset属于关联式容器,底层结构是用二叉树实现。
set和multiset区别:
- set不允许容器中有重复的元素
- multiset允许容器中有重复的元素
两者只需要包含一个头文件#include <set>
8.2、set构造和赋值
功能描述:创建set容器以及赋值
构造:
- set<T> st; //默认构造函数:
- set(const set &st); //拷贝构造函数
赋值:
- set& operator=(const set &st); //重载等号操作符
#include <iostream>
using namespace std;
#include <set>
//set容器 构造和赋值
void printSet(set<int>& s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
set<int>s1;
//插入数据 只有insert方式
s1.insert(10);
s1.insert(40);
s1.insert(30);
s1.insert(20);
s1.insert(30);
//遍历容器
//set容器特点: 所有元素插入时候自动被排序
//set容器不允许插入重复值(不报错,但是不成功)
printSet(s1);
//拷贝构造
set<int>s2(s1);
printSet(s2);
//赋值
set<int>s3;
s3 = s2;
printSet(s3);
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
set容器在插入时使用insert
set容器插入的数据会自动进行排序
set容器不允许插入重复的数据(不报错,但是无法成功插入)
8.3、set大小和交换
功能描述:
- 统计set容器大小以及交换set容器
函数原型:
- size(); //返回容器中元素的数目
- empty(); //判断容器是否为空
- swap(st); //交换两个集合容器
#include <iostream>
using namespace std;
#include <set>
//set容器 大小和交换
void printSet(set<int>& s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//大小
void test01()
{
set<int> s1;
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
printSet(s1);
//判断是否为空
if (s1.empty())
{
cout << "s1为空" << endl;
}
else
{
cout << "s1不为空" << endl;
cout << "s1的大小为: " << s1.size() << endl;
}
}
//交换
void test02()
{
set<int> s1;
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
set<int> s2;
s2.insert(100);
s2.insert(300);
s2.insert(200);
s2.insert(400);
cout << "交换前" << endl;
printSet(s1);
printSet(s2);
cout << endl;
cout << "交换后" << endl;
s1.swap(s2);
printSet(s1);
printSet(s2);
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
总结:
- 统计大小——size
- 判断是否为空——empty
- 交换容器——swap
特别提示:
set容器没有重新指定容量的reset
函数,因为如果容量扩大,用0填充的话,那么set中就出现了重复的元素,这是不被允许的。
8.4、set插入和删除
功能描述:
- set容器进行插入数据和删除数据
函数原型:
insert(elem);
//在容器中插入元素。clear();
//清除所有元素erase(pos);
//删除pos迭代器所指的元素,返回下一个元素的迭代器。erase(beg, end);
//删除区间[beg,end)的所有元素 ,返回下一个元素的迭代器。erase(elem);
//删除容器中值为elem的元素。
#include <iostream>
using namespace std;
#include <set>
//set容器 插入和删除
void printSet(set<int>& s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//插入和删除
void test01()
{
set<int> s1;
//插入
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
printSet(s1);
//删除
s1.erase(s1.begin());
printSet(s1);
s1.erase(30);
printSet(s1);
//清空
//s1.erase(s1.begin(), s1.end());
s1.clear();
printSet(s1);
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
- 插入——insert
- 删除——erase
- 清空——clear
8.5、set查找和统计
功能描述:
- 对set容器进行查找数据以及统计数据
函数原型:
- find(key); //查找key是否存在,若存在,返回该键的元素的迭代器;若不存在,返回set.end();(最后一位的下一位)
- count(key); //统计key的元素个数(set容器=1;multiset可能不=1)
#include <iostream>
using namespace std;
#include <set>
//set容器 查找和统计
void test01()
{
set<int> s1;
//插入
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
//查找
set<int>::iterator pos = s1.find(30);
if (pos != s1.end())
{
cout << "找到了元素 : " << *pos << endl;
}
else
{
cout << "未找到元素" << endl;
}
//统计
int num = s1.count(30);
cout << "num = " << num << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
- 查找——find(返回的是迭代器)
- 统计——count(对于set,结果为0或者为1)
8.6、set和multiset区别
学习目标:
- 掌握set和multiset的区别
区别:
- set不可以插入重复数据,而multiset可以
- set插入数据的同时会返回插入结果,表示插入是否成功
- multiset不会检测数据,因此可以插入重复数据
#include <iostream>
using namespace std;
#include <set>
//set和multiset区别
void test01()
{
set<int> s;
//对组
pair<set<int>::iterator, bool> ret = s.insert(10);
if (ret.second)
{
cout << "第一次插入成功!" << endl;
}
else
{
cout << "第一次插入失败!" << endl;
}
ret = s.insert(10);
if (ret.second) {
cout << "第二次插入成功!" << endl;
}
else {
cout << "第二次插入失败!" << endl;
}
//multiset
multiset<int> ms;
ms.insert(10);
ms.insert(10);
for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
- 如果不允许插入重复数据可以利用set
(set容器的insert函数利用对组pair的迭代器和布尔值,返回是否插入成功,当插入重复数据时,布尔值为false)
- 如果需要插入重复数据利用multiset
(而multiset就不用返回布尔值,因此可以插入重复数据)
8.7、pair组队创建
功能描述:
- 成对出现的数据,利用对组可以返回两个数据
两种创建方式:
- pair<type, type> p ( value1, value2 );
- pair<type, type> p = make_pair( value1, value2 );
#include <iostream>
using namespace std;
#include <string>
//pair对组创建
void test01()
{
//第一种方式
pair<string, int> p("Tom", 20);
cout << "姓名: " << p.first << " 年龄: " << p.second << endl;
//第二种方式
pair<string, int> p2 = make_pair("Jerry", 10);
cout << "姓名: " << p2.first << " 年龄: " << p2.second << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结:两种方式都可以可以创建对组,记住一种即可
8.8、set容器排序
学习目标:
- set容器默认排序规则为从小到大,掌握如何改变排序规则
主要技术点:
- 利用仿函数,可以改变排序规则
示例一 set存放内置数据类型
#include <iostream>
using namespace std;
#include <set>
//set容器 排序
class MyCompare
{
public:
bool operator()(int v1, int v2) const
{
return v1 > v2;
}
};
void test01()
{
set<int> s1;
s1.insert(10);
s1.insert(40);
s1.insert(20);
s1.insert(30);
s1.insert(50);
//默认从小到大
for (set<int>::iterator it = s1.begin(); it != s1.end(); it++) {
cout << *it << " ";
}
cout << endl;
//指定排序规则
set<int, MyCompare> s2;
s2.insert(10);
s2.insert(40);
s2.insert(20);
s2.insert(30);
s2.insert(50);
for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结:利用仿函数可以指定set容器的排序规则
示例二 set存放自定义数据类型
#include <iostream>
using namespace std;
#include <set>
#include <string>
//set容器排序 存放自定义数据类型
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
class comparePerson
{
public:
bool operator()(const Person& p1, const Person& p2) const
{
//按照年龄进行排序 降序
return p1.m_Age > p2.m_Age;
}
};
void test01()
{
set<Person, comparePerson> s;
//创建对象
Person p1("刘备", 23);
Person p2("关羽", 27);
Person p3("张飞", 25);
Person p4("赵云", 21);
//插入数据
s.insert(p1);
s.insert(p2);
s.insert(p3);
s.insert(p4);
for (set<Person, comparePerson>::iterator it = s.begin(); it != s.end(); it++)
{
cout << "姓名: " << it->m_Name << " 年龄: " << it->m_Age << endl;
}
}
int main()
{
test01();
system("pause");
return 0;
}
总结:对于自定义数据类型,set必须指定排序规则才可以插入数据
(利用仿函数,可以实现自定义复杂的排序规则)
9、map/multimap容器(字典)
9.1、map基本概念
简介:
- map中所有元素都是pair
- pair中第一个元素为key(键值),起到索引作用,第二个元素为value(实值)
- 所有元素都会根据元素的键值自动排序
本质:
- map/multimap属于关联式容器,底层结构是用二叉树实现。
优点:
- 可以根据key值快速找到value值
map和multimap区别:
- map不允许容器中有重复key值元素
- multimap允许容器中有重复key值元素
9.2、map构造和赋值
功能描述:
- 对map容器进行构造和赋值操作
函数原型:
构造:
- map<T1, T2> mp; //map默认构造函数:
- map(const map &mp); //拷贝构造函数
赋值:
- map& operator=(const map &mp); //重载等号操作符
#include <iostream>
using namespace std;
#include <map>
//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 test01()
{
//创建map容器
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(pair<int, int>(4, 40));
printMap(m);
map<int, int>m2(m); //拷贝构造
printMap(m2);
map<int, int>m3;
m3 = m2; //赋值
printMap(m3);
}
int main()
{
test01();
system("pause");
return 0;
}
总结:map中所有元素都是成对出现,插入数据时候要使用对组
map元素根据键值进行排序,并且输出的时候first指向键值,second指向实值
9.3、map大小和交换
功能描述:
- 统计map容器大小以及交换map容器
函数原型:
- size(); //返回容器中元素的数目
- empty(); //判断容器是否为空
- swap(st); //交换两个集合容器
#include <iostream>
using namespace std;
#include <map>
//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 test01()
{
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 << "m的大小为: " << m.size() << endl;
}
}
//交换
void test02()
{
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));
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;
printMap(m);
printMap(m2);
cout << "交换后" << endl;
m.swap(m2);
printMap(m);
printMap(m2);
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
总结:
- 统计大小——size
- 判断是否为空——empty
- 交换容器——swap
9.4、map插入和删除
功能描述:
- map容器进行插入数据和删除数据
函数原型:
insert(elem);
//在容器中插入元素。clear();
//清除所有元素erase(pos);
//删除pos迭代器所指的元素,返回下一个元素的迭代器。erase(beg, end);
//删除区间[beg,end)的所有元素 ,返回下一个元素的迭代器。erase(key);
//删除容器中值为key的元素。
#include <iostream>
using namespace std;
#include <map>
//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 test01()
{
//插入
map<int, int> m;
//第一种插入方式
m.insert(pair<int, int>(1, 10));
//第二种插入方式
m.insert(make_pair(2, 20));
//第三种插入方式
m.insert(map<int, int>::value_type(3, 30));
//第四种插入方式
m[4] = 40;
//[]不建议插入,用途:可以利用key访问到value
//cout << m[5] << endl;
printMap(m);
//删除
m.erase(m.begin());
printMap(m);
m.erase(3);
printMap(m);
//清空
m.erase(m.begin(), m.end());
m.clear();
printMap(m);
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
- map插入方式很多,记住一种即可
- 插入——insert
(第三种过长,不建议使用;第四种输出键值错误时,实值自动赋为0,不建议使用,可以用来访问对应键值的value)
- 删除——erase
- 清空——clear
9.5、map查找和统计
功能描述:
- 对map容器进行查找数据以及统计数据
函数原型:
- find(key); //查找key是否存在,若存在,返回该键的元素的迭代器;若不存在,返回map.end();
- count(key); //统计key的元素个数
#include <iostream>
using namespace std;
#include <map>
//map容器 查找和统计
void test01()
{
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));
//查找
map<int, int>::iterator pos = m.find(3);
if (pos != m.end())
{
cout << "找到了元素 key = " << (*pos).first << " value = " << pos->second << endl;
}
else
{
cout << "未找到元素" << endl;
}
//统计
int num = m.count(3);
cout << "num = " << num << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
查找——find(返回的是迭代器)
统计——count(对于map,结果为0或为1;对于multimap可能不为1)
9.6、map容器排序
学习目标:
- map容器默认排序规则为 按照key值进行 从小到大排序,掌握如何改变排序规则
主要技术点:
- 利用仿函数,可以改变排序规则
#include <iostream>
using namespace std;
#include <map>
//map容器 排序
class MyCompare {
public:
bool operator()(int v1, int v2) {
return v1 > v2;
}
};
void test01()
{
//默认从小到大排序
//利用仿函数实现从大到小排序
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;
}
}
int main()
{
test01();
system("pause");
return 0;
}
总结:
- 利用仿函数可以指定map容器的排序规则
- 对于自定义数据类型,map必须要指定排序规则,同set容器
10、员工案例
10.1、案例描述
- 公司今天招聘了10个员工(ABCDEFGHIJ),10名员工进入公司之后,需要指派员工在那个部门工作
- 员工信息有: 姓名 工资组成;部门分为:策划、美术、研发
- 随机给10名员工分配部门和工资
- 通过multimap进行信息的插入 key(部门编号) value(员工)
- 分部门显示员工信息
10.2、实现步骤
- 创建10名员工,放到vector中
- 遍历vector容器,取出每个员工,进行随机分组
- 分组后,将员工部门编号作为key,具体员工作为value,放入到multimap容器中
- 分部门显示员工信息
#include<iostream>
using namespace std;
#include <vector>
#include <string>
#include <map>
#include <ctime>
/*
- 公司今天招聘了10个员工(ABCDEFGHIJ),10名员工进入公司之后,需要指派员工在那个部门工作
- 员工信息有: 姓名 工资组成;部门分为:策划、美术、研发
- 随机给10名员工分配部门和工资
- 通过multimap进行信息的插入 key(部门编号) value(员工)
- 分部门显示员工信息
*/
#define CEHUA 0
#define MEISHU 1
#define YANFA 2
class Worker
{
public:
string m_Name;
int m_Salary;
};
void createWorker(vector<Worker>&v)
{
string nameSeed = "ABCDEFGHIJ";
for (int i = 0; i < 10; i++)
{
Worker worker;
worker.m_Name = "员工";
worker.m_Name += nameSeed[i];
worker.m_Salary = rand() % 10000 + 10000; // 10000 ~ 19999
//将员工放入到容器中
v.push_back(worker);
}
}
//员工分组
void setGroup(vector<Worker>&v,multimap<int,Worker>&m)
{
for (vector<Worker>::iterator it = v.begin(); it != v.end(); it++)
{
//产生随机部门编号
int deptId = rand() % 3; // 0 1 2
//将员工插入到分组中
//key部门编号,value具体员工
m.insert(make_pair(deptId, *it));
}
}
void showWorkerByGourp(multimap<int,Worker>&m)
{
// 0 A B C 1 D E 2 F G ...
cout << "策划部门:" << endl;
multimap<int,Worker>::iterator pos = m.find(CEHUA);
int count = m.count(CEHUA); // 统计具体人数
int index = 0;
for (; pos != m.end() && index < count; pos++ , index++)
{
cout << "姓名: " << pos->second.m_Name << " 工资: " << pos->second.m_Salary << endl;
}
cout << "----------------------" << endl;
cout << "美术部门: " << endl;
pos = m.find(MEISHU);
count = m.count(MEISHU); // 统计具体人数
index = 0;
for (; pos != m.end() && index < count; pos++, index++)
{
cout << "姓名: " << pos->second.m_Name << " 工资: " << pos->second.m_Salary << endl;
}
cout << "----------------------" << endl;
cout << "研发部门: " << endl;
pos = m.find(YANFA);
count = m.count(YANFA); // 统计具体人数
index = 0;
for (; pos != m.end() && index < count; pos++, index++)
{
cout << "姓名: " << pos->second.m_Name << " 工资: " << pos->second.m_Salary << endl;
}
}
int main() {
srand((unsigned int)time(NULL));
//1、创建员工
vector<Worker>vWorker;
createWorker(vWorker);
//2、员工分组
multimap<int, Worker>mWorker;
setGroup(vWorker, mWorker);
//3、分组显示员工
showWorkerByGourp(mWorker);
测试
//for (vector<Worker>::iterator it = vWorker.begin(); it != vWorker.end(); it++)
//{
// cout << "姓名: " << it->m_Name << " 工资: " << it->m_Salary << endl;
//}
system("pause");
return 0;
}
总结:
- 当数据以键值对形式存在,可以考虑用map 或 multimap