C++STL之容器
STL的概述
STL(Standard Template Library,标准模板库)
STL的6大组件：容器、算法、迭代器、适配器、仿函数、空间配置
容器：存放数据
算法：操作数据
迭代器：算法 通过迭代器 操作 容器
适配器：为算法 提供更多的接口
仿函数：为算法 提供策略
空间配置：为算法、容器提供动态空间
算法分类：质变算法、非质变算法
质变算法：会更改容器的值（ 拷贝，替换，删除等等 ）
非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻
找极值等等
什么是迭代器？
迭代器：算法和容器的桥梁，每一个容
器有着与之对应的迭代器
string容器
1、构造函数以及赋值
、构造函数以及赋值
1 3.1.2.1 string 构造函数
2 string();//创建一个空的字符串 例如: string str;
3 string(const string& str);//使用一个string对象初始化另一个string对象
4 string(const char* s);//使用字符串s初始化
5 string(int n, char c);//使用n个字符c初始化 v
6 3.1.2.2 string基本赋值操作
7 string& operator=(const char* s);//char*类型字符串 赋值给当前的字符串
8 string& operator=(const string &s);//把字符串s赋给当前的字符串
9 string& operator=(char c);//字符赋值给当前的字符串
10 string& assign(const char *s);//把字符串s赋给当前的字符串
11 string& assign(const char *s, int n);//把字符串s的前n个字符赋给当前的字符串
12 string& assign(const string &s);//把字符串s赋给当前字符串
13 string& assign(int n, char c);//用n个字符c赋给当前字符串
14 string& assign(const string &s, int start, int n);//将s从start开始n个字符
赋值给字符串代码演示
1 void test01()
2 {
3 string str1("hello world");
4 cout<小结：assign是赋值的意思，常见
2、string存取字符操作
1 char& operator[ ](int n);//通过[ ]方式取字符
2 char& at(int n);//通过at方法获取字符
1 void test02()
2 {
3 string str1="hello world";
4 cout<3、string拼接操作
1 3.1.2.4
2 string& operator+=(const string& str);//重载+=操作符
3 string& operator+=(const char* str);//重载+=操作符
4 string& operator+=(const char c);//重载+=操作符
5 string& append(const char *s);//把字符串s连接到当前字符串结尾
6 string& append(const char *s, int n);//把字符串s的前n个字符连接到当前字符串
结尾
7 string& append(const string &s);//同operator+=()
8 string& append(const string &s, int pos, int n);//把字符串s中从pos开始的n个
字符连接到当前字符串结尾
9 string& append(int n, char c);//在当前字符串结尾添加n个字符c1 void test03()
2 {
3 string str1="hello";
4 str1 += "world";
5 cout<4、string查找和替换
1int find(const string& str, int pos = 0) const; //查找str第一次出现位置,从p
os开始查找
2 int find(const char* s, int pos = 0) const; //查找s第一次出现位置,从pos开
始查找
3 int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符
第一次位置
4 int find(const char c, int pos = 0) const; //查找字符c第一次出现位置
5 int rfind(const string& str, int pos = npos) const;//查找str最后一次位置,从
pos开始查找
6 int rfind(const char* s, int pos = npos) const;//查找s最后一次出现位置,从po
s开始查找
7 int rfind(const char* s, int pos, int n) const;//从pos查找s的前n个字符最后
一次位置
8 int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
9 string& replace(int pos, int n, const string& str); //替换从pos开始n个字符
为字符串str
10 string& replace(int pos, int n, const char* s); //替换从pos开始的n个字符为
字符串s
5、string比较操作
1 > < == != 运算符 可用
2 /*
3 compare函数在>时返回 1，<时返回 ‐1，==时返回 0。
4 比较区分大小写，比较时参考字典顺序，排越前面的越小。
5 大写的A比小写的a小。
6 */
7 int compare(const string &s) const;//与字符串s比较
8 int compare(const char *s) const;//与字符串s比较
6、提取string子串
1 string substr(int pos = 0, int n = npos) const;//返回由pos开始的n个字符组成
的字符串
1 void test06()
2 {
3 string str1="hehehe:hahaha:xixixi:lalala";
4 int pos = 0;
5 while(1)
6 {
7 int ret = str1.find(":", pos);
8 if(ret < 0)
9 {
10 string tmp = str1.substr(pos, str1.size()‐pos);
11 cout<7、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);//在指定位置插入n个字符c
4 string& erase(int pos, int n = npos);//删除从Pos开始的n个字符
8、 string和c-style字符串转换
vector容器
1、vector的概述
vector容器：单端动态数组容器
push_back尾部插入元素、pop_back尾部删除元素
front()头元素、back()尾元素
begin()得到的是 容器的 起始迭代器（首元素的位置）
end() 得到的是 结束迭代器（尾元素的下一个元素位置）
必须包含头文件：#include
1 #include
2 #include
3 using namespace std;
4 void test01()
5 {
6 vector v1;
7 v1.push_back(10);
8 v1.push_back(30);
9 v1.push_back(50);
10 v1.push_back(20);
11 v1.push_back(40);
12
13 //遍历容器
14 //定义一个迭代器iterator 保存是元素的位置
15 vector::iterator it=v1.begin();
16 for(;it!=v1.end(); it++)
17 {
18 //*it == int
19 cout<<*it<<" ";
20 }
21 cout< vector的未雨绸缪机制：
1 void test01()
2 {
3 vector v1;
4 cout<<"容量:"<::iterator it;
6 int i=0;
7 int count = 0;
8 for(i=1;i<=1000;i++)
9 {
10 v1.push_back(1);
11 if(it != v1.begin())
12 {
13 count++;
14 cout<<"第"< 2、vector API
1 3.2.4.1 vector构造函数
2 vector v; //采用模板实现类实现，默认构造函数
3 vector(v.begin(), v.end());//将v[begin(), end())区间中的元素拷贝给本身。
4 vector(n, elem);//构造函数将n个elem拷贝给本身。
5 vector(const vector &vec);//拷贝构造函数。
6
7 //例子 使用第二个构造函数 我们可以...
8 int arr[] = {2,3,4,1,9};
9 vector v1(arr, arr + sizeof(arr) / sizeof(int));
10 3.2.4.2 vector常用赋值操作
11 assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
12 assign(n, elem);//将n个elem拷贝赋值给本身。
13 vector& operator=(const vector &vec);//重载等号操作符
14 swap(vec);// 将vec与本身的元素互换。
15 3.2.4.3 vector大小操作
16 size();//返回容器中元素的个数
17 empty();//判断容器是否为空
18 resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
如果容器变短，则末尾超出容器长度的元素被删除。
19 resize(int num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新
位置。如果容器变短，则末尾超出容器长>度的元素被删除。
20 capacity();//容器的容量
21 reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。
22 3.2.4.4 vector数据存取操作
23 at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。
24 operator[];//返回索引idx所指的数据，越界时，运行直接报错
25 front();//返回容器中第一个数据元素
26 back();//返回容器中最后一个数据元素
27 3.2.4.5 vector插入和删除操作
28 insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元
素ele.
29 push_back(ele); //尾部插入元素ele
30 pop_back();//删除最后一个元素
31 erase(const_iterator start, const_iterator end);//删除迭代器从start到end之
间的元素
32 erase(const_iterator pos);//删除迭代器指向的元素
33 clear();
1 #include
2 #include
3 using namespace std;
4 void test01()
5 {
6 vector v1;
7 v1.reserve(1000);//预留空间
8
9 cout<<"容量:"<::iterator it;
11 int i=0;
12 int count = 0;
13 for(i=1;i<=1000;i++)
14 {
15 v1.push_back(1);
16 if(it != v1.begin())
17 {
18 count++;
19 cout<<"第"< &v)
25 {
26 vector::iterator it;
27 for(it=v.begin(); it!=v.end();it++)
28 {
29 cout<<*it<<" ";
30 }
31 cout< v1(5,100);
37 printVectorInt(v1);
38
39 vector v2 = v1;
40 printVectorInt(v2);
41
42 vector v3(v1.begin(), v1.end());
43 printVectorInt(v3);
44
45 vector v4;
46 // v4 = v3;
47 v4.assign(10,10);
48 printVectorInt(v4);
49
50 //交换
51 v3.swap(v4);
52 printVectorInt(v3);
53 printVectorInt(v4);
54
55 cout<<"大小:"< v5;
58 if(v5.empty())
59 {
60 cout<<"空"< v6(10, 30);
68 cout<<"大小:"< 1 void test03()
2 {
3 vector v1;
4 v1.push_back(10);
5 v1.push_back(20);
6 v1.push_back(30);
7 v1.push_back(40);
8 v1.push_back(50);
9
10 cout<<"头元素:"< 3、巧用swap收缩空间
1 void test04()
2 {
3 vector v1;
4 v1.reserve(1000);
5 v1.assign(5,100);
6 cout<<"大小:"<(v1).swap(v1);
9 cout<<"大小:"< 4、vector容器 嵌套 容器
1 void test05()
2 {
3 vector v1(5,10);
4 vector v2(5,100);
5 vector v3(5,1000);
6
7 //需求：定义一个容器 存放v1 v2 v3
8 vector< vector > v;
9 v.push_back(v1);
10 v.push_back(v2);
11 v.push_back(v3);
12
13 //遍历
14 vector< vector >::iterator it;
15 for(it=v.begin(); it!=v.end(); it++)
16 {
17 //*it == vector
18 vector::iterator mit;
19 for(mit=(*it).begin();mit!=(*it).end();mit++ )
20 {
21 //*mit == int
22 cout<<*mit<<" ";
23 }
24 cout< 5、使用算法 对 vector容器排序
1 #include//算法头文件
2 bool myCompare(int value1, int value2)
3 {
4 return value1 v1;
9 v1.push_back(20);
10 v1.push_back(60);
11 v1.push_back(30);
12 v1.push_back(50);
13 v1.push_back(40);
14 v1.push_back(10);
15 printVectorInt(v1);
16
17 //sort算法排序
18 sort(v1.begin(), v1.end());
19 //sort(v1.begin(), v1.end(), greater());
20 //sort(v1.begin(), v1.end(), myCompare);
21 printVectorInt(v1);
22 } 6、vector存放自定义数据类型
1 class Person
2 {
3 friend void printVectorPerson(vector &v);
4 friend bool myComparePerson(const Person &ob1, const Person &ob2);
5 private:
6 int num;
7 string name;
8 float score;
9 public:
10 Person(){}
11 Person(int num, string name, float score)
12 {
13 this‐>num = num;
14 this‐>name = name;
15 this‐>score = score;
16 }
17 #if 0
18 //方法2：重载自定义数据的<运算符
19 bool operator<(const Person &ob)
20 {
21 return this‐>num < ob.num;
22 }
23 #endif
24 };
25 void printVectorPerson(vector &v)
26 {
27 vector::iterator it;
28 for(it=v.begin(); it!=v.end(); it++)
29 {
30 //*it == Person
31 cout<<(*it).num<<" "<<(*it).name<<" "<<(*it).score< ob2.num;
40 }
41
42 void test07()
43 {
44 vector v;
45
46 v.push_back(Person(100, "lucy", 88.8f));
47 v.push_back(Person(103, "bob", 99.8f));
48 v.push_back(Person(103, "tom", 77.8f));
49 v.push_back(Person(103, "德玛", 88.8f));
50 v.push_back(Person(101, "小法", 66.8f));
51
52 printVectorPerson(v);
53 //方法1：对于自定义容器排序 必须实现 排序规则
54 sort(v.begin(), v.end(), myComparePerson);
55 //方法2：重载自定义数据的<运算符
56 //sort(v.begin(), v.end());
57 cout<<"‐‐‐‐‐‐‐‐‐‐‐‐‐‐"< deque容器
1、deque概述
deque:双端动态数组
Deque容器和vector容器最大的差异，
一在于deque允许使用常数项时间对头端进行元素的插入和删除操作。
二在于deque没有容量的概念。
2、deque的API
引入，什么是随机访问迭代器
如果迭代器能+1 那么该迭代器 为随机访问迭代器
1 3.3.3.1 deque构造函数
2 deque deqT;//默认构造形式
3 deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。
4 deque(n, elem);//构造函数将n个elem拷贝给本身。
5 deque(const deque &deq);//拷贝构造函数。
6 3.3.3.2 deque赋值操作
7 assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
8 assign(n, elem);//将n个elem拷贝赋值给本身。
9 deque& operator=(const deque &deq); //重载等号操作符
10 swap(deq);// 将deq与本身的元素互换
11 3.3.3.3 deque大小操作
12 deque.size();//返回容器中元素的个数
13 deque.empty();//判断容器是否为空
14 deque.resize(num);//重新指定容器的长度为num,若容器变长，则以默认值填充新位
置。如果容器变短，则末尾超出容器长度的元素被删除。
15 deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填
充新位置,如果容器变短，则末尾超出容器长度的元素被删除。
16 3.3.3.4 deque双端插入和删除操作
17 push_back(elem);//在容器尾部添加一个数据
18 push_front(elem);//在容器头部插入一个数据
19 pop_back();//删除容器最后一个数据
20 pop_front();//删除容器第一个数据
21 3.3.3.5 deque数据存取
22 at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range。
23 operator[];//返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
24 front();//返回第一个数据。
25 back();//返回最后一个数据
26 3.3.3.6 deque插入操作
27 insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置。
28 insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
29 insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
30 3.3.3.7 deque删除操作
31 clear();//移除容器的所有数据
32 erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
33 erase(pos);//删除pos位置的数据，返回下一个数据的位置 案例
1 #include
2 #include
3 using namespace std;
4 void printfDequeInt(deque &d)
5 {
6 deque::iterator it;
7 for(it=d.begin(); it!=d.end();it++)
8 {
9 cout<<*it<<" ";
10 }
11 cout< d1;
17 d1.push_back(1);
18 d1.push_back(2);
19 d1.push_back(3);
20 d1.push_front(4);
21 d1.push_front(5);
22 d1.push_front(6);
23 printfDequeInt(d1);//6 5 4 1 2 3
24
25 cout<<"大小:"< 3、deque容器的案例
vector存放的数据 没有多大的规律 只是纪录数据。
deque容器：用于类似竞技的数据
有5名选手：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中
最低分，取平均分。
1. 创建五名选手，放到vector中
2. 遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque
容器中
3. sort算法对deque容器中分数排序，pop_back pop_front去除最高和最低分
4. deque容器遍历一遍，累加分数，累加分数/d.size()
5. person.score = 平均分
1 #include
2 class Player
3 {
4 public:
5 string name;
6 float score;
7 public:
8 Player(){}
9 Player(string name,float score=0.0f)
10 {
11 this‐>name = name;
12 this‐>score=score;
13 }
14 };
15 void createPlayer(vector &v)
16 {
17 string seedName = "ABCDE";
18 int i=0;
19 for(i=0;i<5;i++)
20 {
21 string tmpName = "选手";
22 tmpName+=seedName[i];
23
24 v.push_back(Player(tmpName));
25 }
26 }
27 #include
28 #include
29 #include
30 void playGame(vector &v)
31 {
32 //设置随机数 种子
33 srand(time(NULL));
34 //每名选手都要参加
35 vector::iterator it;
36 for(it=v.begin(); it!=v.end();it++)
37 {
38 //10个评委打分
39 deque d;
40 int i=0;
41 for(i=0;i<10;i++)
42 {
43 d.push_back(rand()%41+60);
44 }
45
46 // 对d容器排序
47 sort(d.begin(),d.end());
48
49 //去掉最高分
50 d.pop_back();
51 //去掉最低分
52 d.pop_front();
53
54 //求总分数
55 (*it).score = accumulate(d.begin(),d.end(), 0)/d.size();
56 }
57 }
58 void showScore(vector &v)
59 {
60 vector::iterator it;
61 for(it=v.begin(); it!=v.end();it++)
62 {
63 cout<<(*it).name<<"所得分数:"<<(*it).score< v;
70 createPlayer(v);
71
72 //开始比赛
73 playGame(v);
74
75 //公布成绩
76 showScore(v);
77 } 小结，存放Person类的时候，常用Vector来存，然后Person之间的关系（隶属于那个部门）再用Deque或者Map来存
stack栈容器
stack是一种先进后出(First In Last Out,FILO)的数据结构。
操作数据的一端 叫栈顶。
top永远指向栈顶元素。
栈容器没有迭代器。不支持遍历行为。
1 3.4.3.1 stack构造函数
2 stack stkT;//stack采用模板类实现， stack对象的默认构造形式：
3 stack(const stack &stk);//拷贝构造函数
4 3.4.3.2 stack赋值操作
5 stack& operator=(const stack &stk);//重载等号操作符
6 3.4.3.3 stack数据存取操作
7 push(elem);//向栈顶添加元素
8 pop();//从栈顶移除第一个元素
9 top();//返回栈顶元素
10 3.4.3.4 stack大小操作
11 empty();//判断堆栈是否为空
12 size();//返回堆栈的大小 
queue队列容器
Queue是一种先进先出(First In First Out,FIFO)的数据结构
出数据的一方叫队头，入数据的一方叫队尾。
queue容器没有迭代器 不支持遍历行为。
1 queue queT;//queue采用模板类实现，queue对象的默认构造形式：
2 queue(const queue &que);//拷贝构造函数
3 3.5.3.2 queue存取、插入和删除操作
4 push(elem);//往队尾添加元素
5 pop();//从队头移除第一个元素
6 back();//返回最后一个元素
7 front();//返回第一个元素
8 3.5.3.3 queue赋值操作
9 queue& operator=(const queue &que);//重载等号操作符
10 3.5.3.4 queue大小操作
11 empty();//判断队列是否为空
12 size();//返回队列的大小 
list链表容器
list是双向循环链表
list容器的迭代器是 双向迭代器。
1 3.6.4.1 list构造函数
2 list lstT;//list采用采用模板类实现,对象的默认构造形式：
3 list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。
4 list(n,elem);//构造函数将n个elem拷贝给本身。
5 list(const list &lst);//拷贝构造函数。
6 3.6.4.2 list数据元素插入和删除操作
7 push_back(elem);//在容器尾部加入一个元素
8 pop_back();//删除容器中最后一个元素
9 push_front(elem);//在容器开头插入一个元素
10 pop_front();//从容器开头移除第一个元素
11 insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
12 insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
13 insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
14 clear();//移除容器的所有数据
15 erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
16 erase(pos);//删除pos位置的数据，返回下一个数据的位置。
17 remove(elem);//删除容器中所有与elem值匹配的元素。
18 3.6.4.3 list大小操作
19 size();//返回容器中元素的个数
20 empty();//判断容器是否为空
21 resize(num);//重新指定容器的长度为num，
22 若容器变长，则以默认值填充新位置。
23 如果容器变短，则末尾超出容器长度的元素被删除。
24 resize(num, elem);//重新指定容器的长度为num，
25 若容器变长，则以elem值填充新位置。
26 如果容器变短，则末尾超出容器长度的元素被删除。
27 3.6.4.4 list赋值操作
28 assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
29 assign(n, elem);//将n个elem拷贝赋值给本身。
30 list& operator=(const list &lst);//重载等号操作符
31 swap(lst);//将lst与本身的元素互换。
32 3.6.4.5 list数据的存取
33 front();//返回第一个元素。
34 back();//返回最后一个元素。
35 3.6.4.6 list反转排序
36 reverse();//反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元
素。
37 sort(); //list排序 1 #include
2 #include
3 #include
4 using namespace std;
5 void printListInt(list &l)
6 {
7 list::iterator it;
8 for(it=l.begin(); it!=l.end();it++)
9 {
10 cout<<*it<<" ";
11 }
12 cout< l1;
18 l1.push_back(10);
19 l1.push_back(20);
20 l1.push_back(30);
21 l1.push_front(40);
22 l1.push_front(50);
23 l1.push_front(60);
24
25 printListInt(l1);//60 50 40 10 20 30
26 //list容器 是双向迭代器 不支持+2 支持++
27 list::iterator it=l1.begin();
28 it++;
29 it++;
30 l1.insert(it, 3, 100);
31 printListInt(l1);//60 50 100 100 100 40 10 20 30
32
33 //删除所有100
34 l1.remove(100);
35 printListInt(l1);//60 50 40 10 20 30
36
37 //对链表排序
38 //STL提供的算法 只支持 随机访问迭代器，而list是双向迭代器 所以sort不支持list
39 // l1.sort(greater());
40 l1.sort();
41 printListInt(l1);//10 20 30 40 50 60
42 }
43
44 int main(int argc, char *argv[])
45 {
46 test01();
47 return 0;
48 }
set容器
1、set容器概述
但是set容器 只有键值，在插入数据的时候 自动根据 键值 排序。不允许有相同的键值。不
能修改set容器的元素值，会破坏set的数据结构。set容器的迭代器是只读迭代器（ const_iterator ）。
1 3.7.2.1 set构造函数
2 set st;//set默认构造函数：
3 mulitset mst; //multiset默认构造函数:
4 set(const set &st);//拷贝构造函数
5 3.7.2.2 set赋值操作
6 set& operator=(const set &st);//重载等号操作符
7 swap(st);//交换两个集合容器
8 3.7.2.3 set大小操作
9 size();//返回容器中元素的数目
10 empty();//判断容器是否为空
11 3.7.2.4 set插入和删除操作
12 insert(elem);//在容器中插入元素。
13 clear();//清除所有元素
14 erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
15 erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
16 erase(elem);//删除容器中值为elem的元素。
17 3.7.2.5 set查找操作
18 find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回se
t.end();
19 count(key);//查找键key的元素个数
20 lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
21 upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
22 equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器 1 #include
2 #include
3 using namespace std;
4 void printSetInt(set &s)
5 {
6 set::iterator it;
7 for(it=s.begin(); it!=s.end();it++)
8 {
9 cout<<*it<<" ";
10 }
11 cout< s1;
17 s1.insert(30);
18 s1.insert(10);
19 s1.insert(20);
20 s1.insert(20);
21 s1.insert(40);
22 printSetInt(s1);
23 }
24
25 int main(int argc, char *argv[])
26 {
27 test01();
28 return 0;
29 } 2、更改set容器的排序规则（定义set容器时 修改）
set
一般都是通过 “仿函数” 修改set容器的排序规则。
1 #include
2 #include
3 using namespace std;
4 //仿函数
5 class MyCompare
6 {
7 public:
8 bool operator()(int v1, int v2)
9 {
10 return v1>v2;
11 }
12 };
13 void printSetInt(set &s)
14 {
15 set::iterator it;
16 for(it=s.begin(); it!=s.end();it++)
17 {
18 cout<<*it<<" ";
19 }
20 cout< &s)
24 {
25 set::iterator it;
26 for(it=s.begin(); it!=s.end();it++)
27 {
28 cout<<*it<<" ";
29 }
30 cout< s1;
37 s1.insert(30);
38 s1.insert(10);
39 s1.insert(20);
40 s1.insert(20);
41 s1.insert(40);
42 printSetInt(s1);
43 }
44
45 int main(int argc, char *argv[])
46 {
47 test01();
48 return 0;
49 } 3、set的API
1 void test03()
2 {
3 set s1;
4 s1.insert(10);
5 s1.insert(30);
6 s1.insert(50);
7 s1.insert(70);
8 s1.insert(90);
9 printSetInt(s1);
10
11 set::const_iterator ret;
12 ret = s1.find(50);
13 if(ret != s1.end())
14 {
15 cout<<"找到的结果:"<<*ret< 4、查找元素的上下限
1 void test04()
2 {
3 set s1;
4 s1.insert(10);
5 s1.insert(30);
6 s1.insert(50);
7 s1.insert(70);
8 s1.insert(90);
9 printSetInt(s1);
10
11 set::const_iterator ret;
12 //lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。(下限)
13 ret = s1.lower_bound(50);
14 if(ret !=s1.end())
15 {
16 cout<<"下限为:"<<*ret<keyElem元素的迭代器（上限）
19 ret = s1.upper_bound(50);
20 if(ret !=s1.end())
21 {
22 cout<<"上限为:"<<*ret<::const_iterator, set::const_iterator> p;
27 p = s1.equal_range(50);
28 if(p.first != s1.end())
29 {
30 cout<<"下限为:"<<*(p.first)< multiset容器
set容器：键值不允许重复
multiset容器：键值可以重复
pair对组
对组(pair)将一对值组合成一个值，这一对值可以具有不同的数据类型，两个值
可以分别用pair的两个公有属性first和second访问
map容器
map容器：每个元素都是 键值-实值 成对存储，自动根据键值排序， 键值不能重复，不能
修改。
1 map构造函数
2 map mapTT;//map默认构造函数:
3 map(const map &mp);//拷贝构造函数
4 3.8.2.2 map赋值操作
5 map& operator=(const map &mp);//重载等号操作符
6 swap(mp);//交换两个集合容器
7 3.8.2.3 map大小操作
8 size();//返回容器中元素的数目
9 empty();//判断容器是否为空
10 3.8.2.4 map插入数据元素操作
11 map.insert(...); //往容器插入元素，返回pair
12 map mapStu;
13 // 第一种 通过pair的方式插入对象
14 mapStu.insert(pair(3, "小张"));
15 // 第二种 通过pair的方式插入对象
16 mapStu.inset(make_pair(‐1, "校长"));
17 // 第三种 通过value_type的方式插入对象
18 mapStu.insert(map::value_type(1, "小李"));
19 // 第四种 通过数组的方式插入值
20 mapStu[3] = "小刘";
21 mapStu[5] = "小王";
22 3.8.2.5 map删除操作
23 clear();//删除所有元素
24 erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
25 erase(beg,end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
26 erase(keyElem);//删除容器中key为keyElem的对组。
27 3.8.2.6 map查找操作
28 find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；/若不存在，返回m
ap.end();
29 count(keyElem);//返回容器中key为keyElem的对组个数。对map来说，要么是0，要么是
1。对multimap来说，值可能大于1。
30 lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
31 upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
32 equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器 案例1：键值的map容器设计
1 #include
2 #include