本文详细介绍了C++ STL中的几种重要容器，包括stack、queue、list、set、multiset、map和multimap。针对每种容器，讲解了其基本概念、构造函数、赋值操作、大小操作、插入和删除、数据存取以及排序等功能，并通过实例演示了各种操作的使用。此外，还探讨了set和multiset、map和multimap之间的区别，以及如何自定义排序规则。
本系列文章为黑马程序员C++教程学习笔记，前面的系列文章链接如下
C++核心编程：P1-＞程序的内存模型
C++核心编程：P2-＞引用
C++核心编程：P3-＞函数提高
C++核心编程：P4-＞类和对象----封装
C++核心编程：P5-＞类和对象----对象的初始化和清理
C++核心编程：P6-＞类和对象----C++对象模型和this指针
C++核心编程：P7-＞类和对象----友元
C++核心编程：P8-＞类和对象----运算符重载
C++核心编程：P9-＞类和对象----继承
C++核心编程：P10-＞类和对象----多态
C++核心编程：P11-＞文件操作
C++核心编程：P12-＞模板----函数模板
C++核心编程：P13-＞模板----类模板
C++核心编程：P14-＞STL----STL初识
C++核心编程：P15-＞STL----常用容器(上)
一、stack容器
1.1 stack基本概念
概念： stack是一种先进后出(First In Last Out, FILO)的数据结构，它只有一个出口。
栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为。
栈中进入数据称为 ---- 入栈push
栈中弹出数据称为 ---- 出栈pop
生活中的栈： 地铁(先进去坐到位置的人最后才能出来)、弹匣(先进去的子弹最后弹出来)
1.2 stack常用接口
功能描述： 栈容器常用的对外接口
构造函数：
stack<T> stk;//stack采用模板类实现， stack对象的默认构造形式
stack(const stack &stk);//拷贝构造函数
赋值操作：stack& operator=(const stack &stk);//重载等号操作符
数据存取：
push(elem);//向栈顶添加元素
pop();//从栈顶移除第一个元素
top();//返回栈顶元素
大小操作：
empty();//判断堆栈是否为空
size();//返回栈的大小
案例： 测试所有的接口
#include <iostream>
#include <stack>
using namespace std;
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;
}
运行，效果如下。
二、queue容器
2.1 queue基本概念
概念：Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口
队列容器允许从一端新增元素，从另一端移除元素。
队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为。
队列中进数据称为 ---- 入队push
队列中出数据称为 ---- 出队pop
生活中的队列：
2.2 queue常用接口
功能描述： 栈容器常用的对外接口
构造函数：
queue<T> que;//queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que);//拷贝构造函数
赋值操作：queue& operator=(const queue &que);//重载等号操作符
数据存取：
push(elem);//往队尾添加元素
pop();//从队头移除第一个元素
back();//返回最后一个元素
front();//返回第一个元素
大小操作：
empty();//判断堆栈是否为空
size();//返回栈的大小
案例： 测试queue常用的接口。
#include <iostream>
#include <string>
#include <queue>
using namespace std;
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->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;
}
运行，效果如下。
三、list容器
3.1 list基本概念
功能： 将数据进行链式存储
链表(list)： 是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。
链表的组成： 链表由一系列结点组成
结点的组成： 一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
STL的链表： STL中的链表是一个双向循环链表。由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器。
list的优点：
采用动态存储分配，不会造成内存浪费和溢出。
链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素。
list的缺点： 链表灵活，但是空间(指针域)和时间(遍历)额外耗费较大。
性质： list有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。
总结： STL中list和vector是两个最常被使用的容器，各有优缺点。
3.2 list构造函数
功能描述： 创建list容器
函数原型：
list<T> lst;//list采用采用模板类实现,对象的默认构造形式：
list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem);//构造函数将n个elem拷贝给本身。
list(const list &lst);//拷贝构造函数。
案例： 测试list的几种构造函数。
#include <iostream>
#include <string>
#include <list>
using namespace std;
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(L1);
printList(L3);
//数值构造
list<int> L4(10, 100);
printList(L4);
}
int main()
{
test01();
system("pause");
return 0;
}
运行，效果如下。
3.3 list赋值和交换
功能描述： 给list容器进行赋值，以及交换list容器
函数原型：
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
list& operator=(const list &lst);//重载等号操作符
swap(lst);//将lst与本身的元素互换。
案例： 测试list赋值和交换操作
#include <iostream>
#include <string>
#include <list>
using namespace std;
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;
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);
L1.swap(L2);
cout << "交换后：" << endl;
printList(L1);
printList(L2);
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
运行，效果如下。
3.4 list大小操作
功能描述： 对list容器的大小进行操作
函数原型：
size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
案例： 测试list大小相关的操作。
#include <iostream>
#include <string>
#include <list>
using namespace std;
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);
if (L1.empty())
{
cout << "L1为空" << endl;
}
else
{
cout << "L1不为空" << endl;
cout << "L1元素个数为： " << L1.size() << endl;
}
L1.resize(10, 10000);
printList(L1);
L1.resize(2);
printList(L1);
}
int main()
{
test01();
system("pause");
return 0;
}
运行，效果如下。
3.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值匹配的元素。
案例： 测试list插入和删除操作。
#include <iostream>
#include <string>
#include <list>
using namespace std;
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;
//尾插
//10 20 30
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
//头插
//300 200 100 10 20 30
L1.push_front(100);
L1.push_front(200);
L1.push_front(300);
printList(L1);
//尾删
//300 200 100 10 20
L1.pop_back();
printList(L1);
//头删
//200 100 10 20
L1.pop_front();
printList(L1);
//insert插入
//200 1000 100 10 20
list<int>::iterator it = L1.begin();
L1.insert(++it, 1000);
printList(L1);
//erase删除
//200 100 10 20
it = L1.begin();
L1.erase(++it);
printList(L1);
//移除
L1.push_back(10000);
L1.push_back(10000);
L1.push_back(10000);
L1.push_back(10000);
//200 100 10 20 10000 10000 10000 10000
printList(L1);
L1.remove(10000);
//200 100 10 20
printList(L1);
//情况
//空了
L1.clear();
printList(L1);
}
int main()
{
test01();
system("pause");
return 0;
}
运行，效果如下。
3.6 list数据存取
功能描述： 对list容器中数据进行存取
函数原型：
front();//返回第一个元素。
back();//返回最后一个元素。
注意：
①list容器中不可以通过[]或者at方式访问数据。这是因为list是链表，不是用连续线性空间存储数据，迭代器也是不支持随机访问的。
②返回第一个元素 ----front
③返回最后一个元素 ----back
案例： 测试list数据存取的功能。
#include <iostream>
#include <list>
using namespace std;
void test01()
{
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<int>::iterator it = L1.begin();
//不可以跳跃访问，即使是+1，只能用++和--
//it = it + 1
it++;
it--;
}
int main()
{
test01();
system("pause");
return 0;
}
运行，效果如下。
3.7 list反转和排序
功能描述： 将容器中的元素反转，以及将容器中的数据进行排序
函数原型：
reverse();//反转链表
sort();//链表排序
案例： 测试list反转和排序功能。
#include <iostream>
#include <string>
#include <list>
using namespace std;
//降序，仿函数
bool myCompare(int v1, int v2)
{
return v1 > v2;
}
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);
cout << "反转前：" << endl;
printList(L1);
cout << "反转后：" << endl;
L1.reverse();
printList(L1);
cout << "排序前：" << endl;
list<int> L2;
L2.push_back(20);
L2.push_back(10);
L2.push_back(50);
L2.push_back(40);
L2.push_back(30);
printList(L2);
cout << "升序排序后：" << endl;
//所有不支持随机访问迭代器的容器，不支持标准算法，所以不能用全局的sort。但是内部会提供一些函数。
//不能用sort(L2.begin(), L2.end());
L2.sort(); //默认升序
printList(L2);
cout << "降序排序后：" << endl;
L2.sort(myCompare); //默认升序
printList(L2);
}
int main()
{
test01();
system("pause");
return 0;
}
运行，效果如下。
3.8 排序案例
案例描述： 将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高
排序规则： 按照年龄进行升序，如果年龄相同按照身高进行降序
整体代码如下。
#include <iostream>
#include <string>
#include <list>
using namespace std;
class Person
{
public:
Person(string name, int age, int height)
{
this->m_Name = name;
this->m_Age = age;
this->m_Height = height;
}
string m_Name;
int m_Age;
int m_Height;
};
bool myCompare(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);
for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
{
cout << "姓名： " << (*it).m_Name << " 年龄： " << (*it).m_Age << " 身高： " << (*it).m_Height << endl;
}
//排序
cout << "-----------------------" << endl;
cout << "排序后： " << endl;
L.sort(myCompare);
for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
{
cout << "姓名： " << (*it).m_Name << " 年龄： " << (*it).m_Age << " 身高： " << (*it).m_Height << endl;
}
}
int main()
{
test01();
system("pause");
return 0;
}
运行，效果如下。
总结：
对于自定义数据类型，必须要指定排序规则，否则编译器不知道如何进行排序。
高级排序只是在排序规则上再进行一次逻辑规则制定，并不复杂。
四、set/multiset容器
4.1 set构造和赋值
基本概念
简介： 所有元素都会在插入时自动被排序
本质： set/multiset属于关联式容器，底层结构是用二叉树实现。
set和multiset区别：
set不允许容器中有重复的元素
multiset允许容器中有重复的元素
构造函数
功能描述： 创建set容器以及赋值
构造：
set<T> st;//默认构造函数：
set(const set &st);//拷贝构造函数
赋值：set& operator=(const set &st);//重载等号操作符
案例： 测试set的几种构造函数。
#include <iostream>
#include <set>
using namespace std;
void printSet(const set<int> &s)
{
for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void func01()
{
set<int> s1;
s1.insert(10);
s1.insert(20);
s1.insert(30);
s1.insert(40);
s1.insert(40); //不会插入重复值
printSet(s1);
set<int> s2(s1);
printSet(s2);
set<int> s3 = s2;
printSet(s3);
}
int main()
{
func01();
system("pause");
return 0;
}
运行，效果如下。
4.2 set大小和交换
功能描述： 统计set容器大小以及交换set容器，不允许resize。
函数原型：
size();//返回容器中元素的数目
empty();//判断容器是否为空
swap(st);//交换两个集合容器
案例： 测试set大小和交换功能。
#include <iostream>
#include <set>
using namespace std;
void printSet(const set<int> &s)
{
for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void func01()
{
set<int> s1;
s1.insert(10);
s1.insert(20);
s1.insert(30);
s1.insert(40);
if (!s1.empty())
{
cout << "不为空，大小为：" << s1.size() << endl;
}
else
{
cout << "为空" << endl;
}
set<int> s2;
s2.insert(100);
s2.insert(200);
s2.insert(300);
s2.insert(400);
cout << "交换前：" << endl;
printSet(s1);
printSet(s2);
cout << "交换后：" << endl;
s1.swap(s2);
printSet(s1);
printSet(s2);
}
int main()
{
func01();
system("pause");
return 0;
}
运行，效果如下。
4.3 set插入和删除
功能描述： set容器进行插入数据和删除数据
函数原型：
insert(elem);//在容器中插入元素。
clear();//清除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(elem);//删除容器中值为elem的元素。
案例： 测试set插入和删除功能。
#include <iostream>
#include <set>
#include <string>
using namespace std;
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;
}
运行，效果如下。
4.4 set查找和统计
功能描述： 对set容器进行查找数据以及统计数据。
函数原型：
find(key);//查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key);//统计key的元素个数，对于set容器，结果不是0就是1。
<br。
案例： 测试set查找和统计功能。
#include <iostream>
#include <set>
#include <string>
using namespace std;
//查找和统计
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;
}
运行，效果如下。
4.5 set和multiset区别
学习目标： 掌握set和multiset的区别
区别：
①set不可以插入重复数据，而multiset可以
②set插入数据的同时会返回插入结果，表示插入是否成功
③multiset不会检测数据，因此可以插入重复数据
首先看看set容器插入操作的定义。可以看到返回的是一个_Pairib类型的数据。
接着我们去看_Pairib的定义，可以看到就是一个队组，里面包含两个元素。第一个是迭代器，返回插入元素的位置。第二个是bool类型的变量，代表插入是否成功。
案例： 测试set连续插入两次相同的值。
#include <iostream>
#include <set>
#include <string>
using namespace std;
//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;
}
}
int main() {
test01();
system("pause");
return 0;
}
运行，可以看出插入失败。
我们再来看看multiset的插入操作的定义，可以看出返回的是插入数据的位置。
案例： 测试multiset连续插入两次相同的值。
#include <iostream>
#include <set>
#include <string>
using namespace std;
//set和multiset区别
void test01()
{
//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;
}
运行，可以看出multiset可以插入两个相同的值。
4.6 set容器排序
学习目标： set容器默认排序规则为从小到大，掌握如何改变排序规则。
主要技术点： 利用仿函数，可以改变排序规则。
案例： set存放内置数据类型
#include <iostream>
#include <set>
#include <string>
using namespace std;
class MyCompare
{
public:
bool operator()(int v1, int v2) {
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存放自定义数据类型
#include <iostream>
#include <set>
#include <string>
using namespace std;
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)
{
//按照年龄进行排序 降序
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;
}
运行，效果如下。
五、map/multimap容器
5.1 map构造和赋值
map基本概念
简介：
①map中所有元素都是pair。
②pair中第一个元素为key(键值)，起到索引作用，第二个元素为value(实值)。
③所有元素都会根据元素的键值自动排序(从小到大)。
本质： map/multimap属于关联式容器，底层结构是用二叉树实现。
优点： 可以根据key值快速找到value值。
map和multimap区别：
②map不允许容器中有重复key值元素
③multimap允许容器中有重复key值元素
案例： 测试map的构造和赋值操作
#include <iostream>
#include <map>
using namespace std;
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> m1;
m1.insert(pair<int, int>(1, 10));
m1.insert(pair<int, int>(3, 30));
m1.insert(pair<int, int>(2, 20));
m1.insert(pair<int, int>(4, 40));
printMap(m1);
map<int, int>m2(m1);
printMap(m2);
map<int, int>m3 = m1;
printMap(m3);
}
int main() {
test01();
system("pause");
return 0;
}
运行，效果如下。
5.2 map大小和交换
功能描述： 统计map容器大小以及交换map容器
函数原型：
size();//返回容器中元素的数目
empty();//判断容器是否为空
swap(st);//交换两个集合容器
案例： 测试map大小和交换功能。
#include <iostream>
#include <map>
using namespace std;
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> m1;
m1.insert(pair<int, int>(1, 10));
m1.insert(pair<int, int>(3, 30));
m1.insert(pair<int, int>(2, 20));
if (m1.empty())
{
cout << "m为空" << endl;
}
else
{
cout << "m不为空" << endl;
cout << "m大小为：" << m1.size() << endl;
}
cout << endl;
cout << "交换前：" << endl;
map<int, int> m2;
m1.insert(pair<int, int>(4, 100));
m1.insert(pair<int, int>(5, 200));
m1.insert(pair<int, int>(6, 300));
printMap(m1);
printMap(m2);
cout << endl;
cout << "交换后：" << endl;
m1.swap(m2);
printMap(m1);
printMap(m2);
}
int main() {
test01();
system("pause");
return 0;
}
运行，效果如下。
5.3 map插入和删除
功能描述： map容器进行插入数据和删除数据
函数原型：
insert(elem);//在容器中插入元素。
clear();//清除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(key);//删除容器中值为key的元素。
案例： 测试map的几种插入和删除方式。
#include <iostream>
#include <map>
using namespace std;
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;
//插入，有4种方式
//1、
m.insert(pair<int, int>(1, 10));
//2、
m.insert(make_pair(2, 20));
//3、
m.insert(map<int, int>::value_type(3, 30));
//4、不建议这种方式。如果键不存在，则会自动创建一个，同时值为0
m[4] = 40;
cout << m[5] << endl;
printMap(m);
m.erase(m.begin());
printMap(m);
m.erase(3); //删除键为3的pair
printMap(m);
m.clear();
printMap(m);
}
int main() {
test01();
system("pause");
return 0;
}
运行，结果如下。
5.4 map查找和统计
功能描述： 对map容器进行查找数据以及统计数据。
函数原型：
find(key);//查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key);//统计key的元素个数，对于map要么为0要么为1。
案例： 测试map的查找和统计功能
#include <iostream>
#include <map>
using namespace std;
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));
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(2);
cout << "num = " << num << endl;
}
int main() {
test01();
system("pause");
return 0;
}
运行， 结果如下。
5.5 map容器排序
学习目标： map容器默认排序规则为 按照key值进行 从小到大排序，掌握如何改变排序规则。
主要技术点: 利用仿函数，可以改变排序规则。
案例： 通过仿函数改变map容器的排序规则。
#include <iostream>
#include <map>
using namespace std;
class myCompare
{
public:
bool operator()(int a, int b)
{
return a > b;
}
};
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>(5, 50));
m.insert(pair<int, int>(4, 40));
m.insert(pair<int, int>(3, 30));
printMap(m);
map<int, int, myCompare> m2;
m2.insert(pair<int, int>(1, 10));
m2.insert(pair<int, int>(2, 20));
m2.insert(pair<int, int>(5, 50));
m2.insert(pair<int, int>(4, 40));
m2.insert(pair<int, int>(3, 30));
for (map<int, int, myCompare> ::iterator it = m2.begin(); it != m2.end(); it++)
{
cout << "Key = " << (*it).first << " Value = " << it->second << endl;
}
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
运行，效果如下。
六、STL案例----员工分组
案例描述
①公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在那个部门工作
②员工信息有: 姓名 工资组成；部门分为：策划、美术、研发
③随机给10名员工分配部门和工资
④通过multimap进行信息的插入 key(部门编号) value(员工)
⑤分部门显示员工信息
实现步骤
①创建10名员工，放到vector中
②遍历vector容器，取出每个员工，进行随机分组
③分组后，将员工部门编号作为key，具体员工作为value，放入到multimap容器中
④分部门显示员工信息
整体代码
#include <iostream>
#include <vector>
#include <string>
#include <map>
using namespace std;
#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;
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 depID = rand() % 3;
m.insert(make_pair(depID, *it));
}
}
void showWorkerByGroup(multimap<int, Worker> &m)
{
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() {
vector<Worker> vWorker;
createWorker(vWorker);
multimap<int, Worker> mWorker;
setGroup(vWorker, mWorker);
showWorkerByGroup(mWorker);
system("pause");
return 0;
}
运行，效果如下。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
