当前位置：首页 > news >正文

C++中STL标准模板库学习记录

news 2025/9/11 8:22:28

文章目录：

- - 1.vector
  - - 1.1 遍历方式
    - 1.2 构造函数
    - 1.3 容量大小问题
    - 1.4 插入和删除
    - 1.5 存取值
    - 1.6 交换两个vectot的元素
    - 1.7 预定义存储空间
  - 2.string
  - 3. deque
  - 4. stack
  - - 4.1 常用函数
  - 5. queue
  - - 5.1 特点
    - 5.2 方法
  - 6. list
  - - 6.1 优点
    - 6.2 缺点
    - 6.3 构造函数
    - 6.4 交换
    - 6.5 大小
    - 6.6 插入和删除
    - 6.7 排序和反转
  - 7. set
  - - 7.1 方法
    - 7.2 pair 对数创建
    - 7.3 排序
  - 8. map
  - - 8.1 插入元素，大小与交换
    - 8.2 查找与统计
    - 8.3 排序

1.vector

1.1 遍历方式

for_each(v.begin(),v.end(),myPrint)// myPrint为自定义vector输出函数

1.2 构造函数

vector v2(v1.begin(),v1.end());
vector v2(10,1000);// 存储10个1000
vector v2(v1);// 将v1赋给v1
vector v2;
v2.assign(10,1000);// 存储10个1000

1.3 容量大小问题

capacity和size的区别
capacity是系统开辟的空间，这个空间可能大于定义的大小，作为备用存储空间
size是开辟的空间大小
一般capacity=size，没有备用空间。
在尾部添加push_back时，系统会找一个足够大的空间，并将原来的数组复制过去，
但一般会额外多开辟新备用空间，防止反复移动整个数组，而导致运行效率降低的问题

1.4 插入和删除

pop_back()删除最后一个元素
insert(v.begin(),100)在开始位置插入100
insert(v.begin(),2,1000)在开始位置插入2个1000
erase(v1.begin())移除第一元素值
erase(v1.begin(),v1.end())// 删除所有元素，不会清除开辟的空间（size）
clear()会清空vetor中的所有元素，包括开辟的空间（size），但是capacity会保留，这时不可以用下标的形式赋值，只能通过push_back函数。

1.5 存取值

可通过[]下标的形式和at()函数
front()返回第一个元素值
back()返回最后一个元素值

1.6 交换两个vectot的元素

v1.swap(v2)交换v1和v2的元素值

1.7 预定义存储空间

reserve(10000) 开辟预留空间，防止vector多次赋值导致的效率降低

#include<iostream>
#include<algorithm>
#include<vector>using namespace std;class Person {public:
string myname;
int myage;
Person(string name, int age) {
myname = name;
myage = age;
}
};
void myPrint(int val) {
cout << val << endl;
}void test() {
vector<int> v;// 定义存储int整形的向量
v.push_back(10);// 向向量中传值
v.push_back(20);
v.push_back(30);
v.push_back(40);vector<int>::iterator pBegin = v.begin();// 定义迭代器，迭代器指向第一个元素
vector<int>::iterator pEnd = v.end();// 定义迭代器，迭代器指向最后一个元素// 遍历vector
while (pBegin != pEnd) {
cout << *pBegin << endl;
pBegin++;
}
// 遍历vector
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << endl;
}
// 遍历vector，加强型循环
for_each(v.begin(), v.end(), myPrint);}
// 存放自定义数据类型
void test01() {
vector<Person>  v;
Person p1("aaa", 10);// 实例化对象
Person p2("bbb", 20);
Person p3("ccc", 30);
Person p4("ddd", 40);v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
cout << "name:" << (*it).myname << "  age:" << (*it).myage << endl;
}
}
// 定义存储自定义对象地址
void test02() {
vector<Person*> v;
Person p1("aaa", 10);
Person p2("aaa", 20);
Person p3("aaa", 30);
Person p4("aaa", 40);v.push_back(&p1);
v.push_back(&p2);
v.push_back(&p3);
v.push_back(&p4);for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++) {
Person *p = (*it);
cout << "name: " << p->myname << "    age: " << p->myage << endl;
}}
// 嵌套存储vector的vector
void test03() {
vector<vector<int>> v;
vector<int> a1;
vector<int> a2;
vector<int> a3;
vector<int> a4;a1.push_back(10);
a1.push_back(20);
a1.push_back(30);
a1.push_back(40);v.push_back(a1);
v.push_back(a2);
v.push_back(a3);
v.push_back(a4);// 需要用到两个for循环，第一个返回的是vector，第二个是遍历返回的vector
for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++) {
for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++) {
cout << *vit << endl;
}
}
}// vector赋值
void printVector(vector<int>& v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";}
cout << endl;
}
// vectot构造函数
void test04() {
vector<int> v1;
for (int i = 0; i < 4; i++) {
v1.push_back(i);
}
printVector(v1);vector<int> v2(v1.begin(), v1.end());
printVector(v2);vector<int> v3(10, 100);
printVector(v3);vector<int> v4(v3);
printVector(v4);}
// vecotr赋值
void test05() {
vector<int> v1;
for (int i = 0; i < 4; i++) {
v1.push_back(i);
}
printVector(v1);vector<int> v2 = v1;
printVector(v2);vector<int> v3;
v3.assign(v1.begin(), v1.end());
printVector(v3);vector<int> v4;
v4.assign(10, 100);// 10个100进行赋值
printVector(v4);
}//vector大小操作
/* TODO capacity和size的区别capacity是系统开辟的空间，这个空间可能大于定义的大小，作为备用存储空间
size是开辟的空间大小
一般capacity=size，没有备用空间。
在尾部添加push_back时，系统会找一个足够大的空间，并将原来的数组复制过去，
但一般会额外多开辟新备用空间，防止反复移动整个数组，而导致运行效率降低的问题
*/void test06() {
vector<int> v1;
for (int i = 0; i < 4; 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, 10);// 指定大，默认用0填充，这里用用10填充
printVector(v1);v1.resize(5);// 指定小，超过部分将被删除
printVector(v1);
}// 插入和删除
void test07() {
vector<int> v1;
for (int i = 0; i < 4; i++) {
v1.push_back(i);
}
printVector(v1);v1.pop_back();// 删除最后一个元素
printVector(v1);v1.insert(v1.begin(), 100);// 在开始位置插入100
printVector(v1);v1.insert(v1.begin(), 2, 1000);// 在开始位置插入两个1000
printVector(v1);v1.erase(v1.begin());// 移除第一个元素值
printVector(v1);v1.erase(v1.begin(), v1.end());// 移除所有元素值
printVector(v1);
v1.clear();// 清空vector
printVector(v1);}//vector存取
void test08() {
vector<int> v1;
// 向v1中存值
for (int i = 0; i < 5; i++) {
v1.push_back(i);
}
// 通过数组下标的形式取值
for (int i = 0; i < 5; i++) {
cout << v1[i] << " ";
}
cout << endl;
// 通过at()函数进行取值
for (int i = 0; i < v1.size(); i++) {
cout << v1.at(i) << " ";
}
cout << endl;
// 取出第一个值和最后一个值
cout << "v1的第一元素为：" << v1.front() << endl;
cout << "v1的最后一个元素：" << v1.back() << endl;
}
// 交换两个vector的值
void test09() {
vector<int> v1;
for (int i = 0; i < 5; i++) {
v1.push_back(i);
}
printVector(v1);vector<int> v2;
for (int i = 10; i > 0; i--) {
v2.push_back(i);
}
printVector(v2);v1.swap(v2);// 交换vector的值
printVector(v1);
printVector(v2);
}void test10() {
vector<int> v1;
v1.reserve(10000);// 数据量比较大，开始使用reserve()预留空间
int num = 0;
int *p = NULL;
for (int i = 0; i < 10000; i++) {
v1.push_back(i);
if (p != &v1[0]) {
p = &v1[0];
num++;
}
}
cout << "num=" << num << endl;
}
int main()
{test01();
test02();
test03();
test04();
test05();
test06();
test07();
test08();
test09();
test10();system("pause");
return 0;
}

2.string

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
using namespace std;void test01()
{
string s1;// 创建空的字符串，调用无参数构造函数
cout << s1 << endl;const char* str = "hello world";
string s2(str);// 将字符指针调用
cout << s2 << endl;string s3(s2);// 用str初始化string
cout << s3 << endl;string s4(10, 'a');// 使用10个a字符初始化字符s4
cout << s4 << endl;
}// 给string赋值
void test02()
{
string str1;
str1 = "hello world!";
cout << str1 << endl;string str2;
str2 = str1;
cout << str2 << endl;string str3;
str3 = 'a';
cout << str3 << endl;string str4;
str4.assign("hello c++");
cout << str4 << endl;string str5;
str5.assign("hello c++", 5);// 存取前5个字符
cout << str5 << endl;
cout << str5 << endl;string str6;
str6.assign(str5, 2);// 传入的是string对象是去掉前2个字符
cout << str6 << endl;string str7;
str7.assign(5, 'x');
cout << str7 << endl;
}// string拼接
void test03() {
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 ");
str3.append("game abcd", 4);// 取前4个字符赋值
cout << "str3=" << str3 << endl;
str3.append(str2, 4, 2);// 取第4个位置开始的2个元素赋值
cout << "str3=" << str3 << endl;
}// 查找
void test04() {
string str1 = "abcdedefg";
int pos = str1.find("de");// 开始从起始位置查找第一次出现的下标
if (pos == -1) {
cout << "未找到" << endl;
}
else {
cout << "pos=" << pos << endl;
}pos = str1.rfind("de");// 查找最后一次出现的下标
cout << "pos=" << pos << endl;}//string 存取
void test05() {
string str = "hello world";
for (int i = 0; i < str.size(); i++) {
cout << str[i];
}
cout << endl;
for (int i = 0; i < str.size(); i++) {
cout << str.at(i);
}
cout << endl;
}// 插入和删除
void test06() {
string str = "hello";
str.insert(1, "111");
cout << str << endl;str.erase(1, 3);// 删除从下标1开始的3个元素
cout << str << endl;
}// 子串
void test07() {
string str = "abcdefg";
string substr = str.substr(1, 3);
cout << "substr=" << substr << endl;string email = "hello world@sina.com";
int pos = email.find("@");
string username = email.substr(0, pos);
cout << "username:" << username << endl;
}
int main()
{
//test01();
//test02();
//test03();
//test04();
//test05();
//test06();
test07();
system("pause");
return 0;
}

3. deque

双端数组

#include<iostream>
#include<algorithm>
#include<deque>using namespace std;/*
deque容器，双端数组，可以对头端进行插入和删除操作
deque和vector区别
vector对于头部的删除插入效率底，deque相对较快
vector对元素的访问速度比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 < 5; 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);deque<int> d5;
d5.assign(10, 100);// 在开始的位置赋值10个100
printDeque(d5);deque<int> d6;
d6.assign(d5.begin(), d5.end());
}// 容量大小
void test02() {
deque<int> d1;
for (int i = 0; i < 5; i++) {
d1.push_back(i);
}
printDeque(d1);// 判断元素时候是否为空
if (d1.empty()) {
cout << "d1为空!" << endl;
}
else {
cout << "d1的大小为：" << d1.size() << endl;
}
d1.resize(15, 1);// 重新设定大小，超过元素使用1填充
printDeque(d1);d1.resize(5);// 重设大小，超过部分将被删除
printDeque(d1);}
// 插入和删除
void test03() {
deque<int> d;
d.push_back(10);// 尾插
d.push_back(20);d.push_front(100);// 头插
d.push_front(200);printDeque(d);d.pop_back();// 返回最后一个元素
d.pop_front();// 返回第一个元素
printDeque(d);d.insert(d.begin(), 1000);// 在开始的位置插入1000
printDeque(d);
d.insert(d.begin(), 2, 10000);// 在开始的位置插入2个1000
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());// 向d中插入d2的所有值
printDeque(d);d.erase(d.begin());// 删除最开始的元素，返回下一个元素的位置d.clear();// 清空d，包括删除size
}// 存取值
void test04() {
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_back(30);
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;
}// 排序，升序
void test05() {
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_back(19);
d.push_back(15);
d.push_back(9);
printDeque(d);sort(d.begin(), d.end());
printDeque(d);}
int main()
{//test01();
//test02();
//test03();
//test04();
test05();
system("pause");
return 0;
}

4. stack

4.1 常用函数

push()// 入栈
pop()// 出栈
top()// 返回栈顶元素
empty()// 判断栈顶是否为空
size()// 栈中元素

#include<iostream>
#include<algorithm>
#include<stack>using namespace std;void test01() {
stack<int> s;s.push(10);            // 进栈
s.push(20);
s.push(30);while (!s.empty()) {    // 判断栈是否为空
cout << "栈顶元素：" << s.top() << endl;
s.pop();// 输出栈顶元素
}
cout << "栈的大小：" << s.size() << endl;
}
int main()
{
test01();
system("pause");
return 0;
}

5. queue

5.1 特点

一端新增元素，一端移除元素
只有队头和队尾可以被外界使用，队列不允许有遍历行为

5.2 方法

push() // 往队尾添加元素
pop()// 从队头移除第一个元素
back()// 返回最后一个元素
front()// 返回第一个元素
empty()// 判断是否为空
size()// 返回栈的大小

#include<iostream>
#include<algorithm>
#include<string>
#include<queue>using namespace std;/*
队列：先进先出，允许一端新增元素，一端移除元素
队列中只有队头和队尾被外界使用，队列不存在遍历行为*/
class Person {
public:
Person(string name, int age) {// 构造函数
this->mName = name;
this->mAge = age;
}
string mName;
int mAge;
};void test01() {
queue<Person> q;Person p1("唐僧", 30);
Person p2("孙悟空", 40);
Person p3("猪八戒", 50);
Person p4("沙僧", 60);q.push(p1);
q.push(p2);
q.push(p3);
q.push(p4);while (!q.empty()) {
// 输出队头元素
cout << "姓名:" << q.front().mName <<
"   年龄:" << q.front().mAge << endl;// 输出队尾元素
cout << "姓名：" << q.back().mName <<
"   年龄：" << q.back().mAge << endl;
cout << endl;
q.pop();
}
cout << "队列大小为："<<q.size() << endl;}int main()
{
test01();
system("pause");
return 0;
}

6. list

链表是一个双向循环链表

6.1 优点

采用动态存储分配，不会造成内存浪费和溢出，插入和删除操作方便

6.2 缺点

遍历效率低下

6.3 构造函数

list L2(L1.begin(),L1.end())// 将L1链表中的值赋给L1
list L3(10,1000)//存放10个1000
list L4()
L4.assign()//存放10个1000

6.4 交换

swap()//交换两个list中的值

6.5 大小

empty()//判断是否为空
size()//输出大小，元素个数
resize()//设置大小，超过原有数组用0填充，未达到，则后面的将被删除

6.6 插入和删除

push_back()// 尾插入
push_front()// 头插入
pop_back()// 尾删除
pop_front()// 头删除

insert(++it)// it是一个指针
erase(++it)// it是一个指针
remove(1000)// 移除list中所有的1000

6.7 排序和反转

reverse()// 反转数组
sort()// 排序数组

在自定义对象（例如Person）存储到list中，需要指定排序的顺序

#include<iostream>
#include<algorithm>
#include<string>
#include<list>using namespace std;
/*
STL中的链表是一个双向循环链表
优点：
采用动态存储分配，不会造成内存浪费和溢出
插入和删除操作十分方便
缺点：
遍历效率低下
*/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<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(10, 1000);// 存放10个1000
printList(L3);
}
// 赋值
void test02() {
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;
printList(L2);list<int>L3;
L3.assign(L2.begin(), L2.end());
printList(L3);list<int>L4;
L4.assign(10, 1000);
printList(L4);
}
// 交换
void test03() {
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.assign(10, 1000);
printList(L2);L2.swap(L1);// 交换printList(L1);
printList(L2);}
// 大小操作
void test04() {list<int> L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printList(L1);if (L1.empty()) {
cout << "不为空" << endl;
}
else {
cout << "L1的大小" << L1.size() << endl;
}// 重新指定大小
L1.resize(10);// 设置大小，超过的用0填充
printList(L1);
L1.resize(2);// 除掉后面超过的长度
printList(L1);}// 插入和删除
void test05() {
list<int> L1;
// 尾插
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);// 头插
L1.push_front(1);
L1.push_front(2);
L1.push_front(3);
L1.push_front(4);
printList(L1);// 尾删
L1.pop_back();
printList(L1);// 头删
L1.pop_front();
printList(L1);// 插入
list<int>::iterator it = L1.begin();
L1.insert(++it, 100);
printList(L1);
// 删除
it = L1.begin();
L1.erase(++it);
printList(L1);// 移除
L1.push_back(1000);
L1.push_back(1000);
L1.push_back(1000);
printList(L1);
L1.remove(1000);
printList(L1);// 清空
L1.clear();
printList(L1);}
// 数据存储
void test06() {
list<int> L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);cout << "第一个元素：" << L1.front() << endl;
cout << "最后一个元素：" << L1.back() << endl;// list中的迭代器是双向迭代器，不支持随机访问
// it = it + 1;是错的}// list反转和排序
void test07() {
list<int> L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(4);
L1.push_back(2);
L1.push_back(1);
L1.push_back(30);
L1.push_back(40);
printList(L1);L1.reverse();// 反转链表
printList(L1);L1.sort();// 排序，按升序进行
printList(L1);
}// 实例
class Person{
public:
Person(string name, int age, int height) {
m_name = name;
m_age = age;
m_height = height;
}
public:
string m_name;
int m_age;
int m_height;
};
// 指定排序规则
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 test08() {
list<Person>L1;
Person p1("刘备", 24, 175);
Person p2("关羽", 23, 185);
Person p3("关羽", 22, 185);
Person p4("关羽", 21, 185);
Person p5("张飞", 21, 170);
Person p6("曹操", 19, 165);
Person p7("典韦", 23, 190);L1.push_back(p1);
L1.push_back(p2);
L1.push_back(p3);
L1.push_back(p4);
L1.push_back(p5);
L1.push_back(p6);
L1.push_back(p7);for (list<Person>::iterator it = L1.begin(); it != L1.end(); it++) {
cout << "姓名：" << it->m_name << "   年龄：" << it->m_age <<
"   身高:" << it->m_height << endl;
}
cout << "----------------------------------------" << endl;
L1.sort(comparePerson);
for (list<Person>::iterator it = L1.begin(); it != L1.end(); it++) {
cout << "姓名：" << it->m_name << "   年龄：" << it->m_age <<
"   身高:" << it->m_height << endl;
}
}
int main()
{
//test01();
//test02();
//test03();
test04();
//test05 ();
//test06();
//test07();
//test08();
system("pause");
return 0;
}

7. set

7.1 方法

inser() // 排除重复元素
empty()// 判断是否为空
size()// 大小
swap()// 交换两个set的元素
erase(s.begin())// 移除最开始的元素
erase(10)// 移除set集合中的10
clear()// 清空set，此时size()为0

set::iterator pos = s.find(1);// 在元素中进行查找，成功后返回位置
s.count(10)// 统计10出现的次数

7.2 pair 对数创建

void test07() {
pair<string, int> p(string(“Tom”), 20);

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

pair<string, int> p2 = make_pair(“Jerry”, 10);
cout << "姓名： " << p2.first << " 年龄： " << p2.second << endl;

}

7.3 排序

sort()// 默认升序排序
可以根据自己定义的规则进行排序，定义一个类

#include<iostream>
#include<algorithm>
#include<set>
#include<string>
using namespace std;
/*
set：
所有元素都会插入时，进行自动排序，属于关联式容器，底层使用二叉树实现
set不允许容器中有重复元素，multiset容器允许有重复元素
*/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(50);
s1.insert(40);
s1.insert(60);
s1.insert(60);
s1.insert(60);
printSet(s1);//赋值
set<int> s2;
s2 = s1;
printSet(s2);// 构造函数
set<int> s3(s2);
printSet(s3);}// 大小
void test02() {
set<int> s1;
s1.insert(120);
s1.insert(10);
s1.insert(20);
s1.insert(40);
s1.insert(720);if (s1.empty()) {
cout << "s1为空" << endl;
}
else {
cout << "s1的大小为：" << s1.size() << endl;
}}
// 交换
void test03() {
set<int> s1;
s1.insert(12);
s1.insert(2);
s1.insert(10);
s1.insert(23);
s1.insert(1);set<int> s2;
s2.insert(5);
s2.insert(4);
s2.insert(3);
s2.insert(2);
s2.insert(1);cout << "交换前" << endl;
printSet(s1);
printSet(s2);
cout << "交换后" << endl;
s1.swap(s2);
printSet(s1);
printSet(s2);}
// 插入和删除
void test04() {set<int> s1;
s1.insert(12);
s1.insert(2);
s1.insert(29);
s1.insert(22);
s1.insert(19);
printSet(s1);// 删除
s1.erase(s1.begin());// 删除第一个元素
printSet(s1);s1.erase(19);// 移除素值为19的元素
printSet(s1);// 清空
s1.clear();
printSet(s1);
}// 查找与统计
void test05() {
set<int> s;
s.insert(12);
s.insert(9);
s.insert(11);
s.insert(2);
s.insert(1);set<int>::iterator pos = s.find(1);
if (pos != s.end()) {
cout << "找到了元素" << *pos << endl;
}
else {
cout << "未找到元素" << endl;
}
int num = s.count(9);
cout << "num=" << num << endl;
}
void test06() {
set<int> s;
pair<set<int>::iterator, bool> ret = s.insert(12);
if (ret.second) {
cout << "第一次插入成功！" << endl;
}
else {
cout << "第一次插入失败！" << endl;
}ret = s.insert(12);
if (ret.second) {
cout << "第二次插入成功！" << endl;
}
else {
cout << "第二次插入失败！" << endl;
}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 << endl;
}
cout << endl;
}// pair对数创建
void test07() {
pair<string, int> p(string("Tom"), 20);cout << "姓名： " << p.first << " 年龄： " << p.second << endl;pair<string, int> p2 = make_pair("Jerry", 10);
cout << "姓名： " << p2.first << " 年龄： " << p2.second << endl;}
// 排序
class MyCompare {
public:
bool operator()(int v1, int v2) {
return v1 > v2;
}
};
void test08() {
set<int> s1;
s1.insert(10);
s1.insert(40);
s1.insert(20);
s1.insert(12);
s1.insert(19);
printSet(s1);set<int, MyCompare> s2;// 降序排序
s2.insert(10);
s2.insert(14);
s2.insert(1);
s2.insert(100);
s2.insert(23);
s2.insert(45);
for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++) {
cout << *it << " ";
}
cout << endl;}// set存放自定义数据类型
class Person {
public:string m_name;
int m_age;
Person(string name, int age) {
this->m_name = name;
this->m_age = age;
}};class comparePerson {
public:
bool operator()(const Person& p1, const Person & p2) {
// 按照年龄进行降序
return p1.m_age > p2.m_age;
}
};void test09() {
set<Person, comparePerson> s;// 指定了set中的排序方式
Person p1("刘备", 23);
Person p2("曹操", 22);
Person p3("张飞", 21);
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();
//test02();
//test03();
//test04();
//test05();
//test06();
//test07();
//test08();
test09();
system("pause");
return 0;
}

8. map

map中所有元素为pair，第一个键，第二个为值
所有元素根据元素的键值自动排序
属于关联式容器，底层由二叉树实现

map不允许容器中所有重复key值
multimap允许容器中重复key值

8.1 插入元素，大小与交换

insert(pair<int,int>(1,10))// 插入键值对
empty()判断是否为空
size()拥有多少键值对
swap()交换两个map中的键值对

8.2 查找与统计

map<int,int>::iterator pos = m.find(3)// 查找map中键为3的键的位置
count(3)// 统计键为3的键值对个数

8.3 排序

按照key值进行从小到大的排序
利用仿函数，能够改变排序的规则

#include<iostream>
#include<algorithm>
#include<map>
#include<string>
using namespace std;
/*
map中所有元素为pair,第一个元素为键，第二个为元素
所有元素根据元素的键值自动排序
属于关联式容器，底层由二叉树实现map不允许容器中有重复key值
multimap允许容器中重复key值
*/
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));
m.insert(pair<int, int>(4, 40));
printMap(m);map<int, int> m2(m);// 拷贝函数
printMap(m2);map<int, int> m3;
m3 = m2;// 赋值
printMap(m3);}// 大小与交换
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));
m.insert(pair<int, int>(4, 40));
if (m.empty()) {
cout << "m为空" << endl;
}
else {
cout << "m不为空" << endl;
cout << "m的大小为" << m.size() << endl;
}map<int, int> m1;
m1.insert(pair<int, int>(10, 100));
m1.insert(pair<int, int>(20, 200));
m1.insert(pair<int, int>(30, 300));
m1.insert(pair<int, int>(40, 400));
cout << "交换前：" << endl;
printMap(m);
printMap(m1);
cout << "-----------------------------------" << endl;
cout << "交换后：" << endl;
m.swap(m1);
printMap(m);
printMap(m1);
}// 插入和删除
void test03() {
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;printMap(m);m.erase(m.begin());// 删除最开始的元素
m.erase(3);// 删除键值为3的对数
printMap(m);// 清空
m.erase(m.begin(), m.end());
printMap(m);}//查找与统计
void test04() {
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));// 查找
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;// 统计键值为3出现的次数
}// 排序
// 按照key值进行从小到大的排序
// 利用仿函数，能够改变排序的规则
class MyCompare {
public:
bool operator()(int v1, int v2) {
return v1 > v2;
}
};void test05() {
map<int, int, MyCompare> m;// 在这里会作降序排序
m.insert(make_pair(1, 10));
m.insert(make_pair(3, 30));
m.insert(make_pair(2, 20));
m.insert(make_pair(6, 60));
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();
//test02();
//test03();
//test04();
test05();
system("pause");
return 0;
}