C++学习记录006——C++STL

只有不断前进

已于 2024-08-29 23:03:05 修改

阅读量586

点赞数 10

文章标签： c++ 学习

于 2024-08-29 09:01:08 首次发布

本文链接：https://blog.csdn.net/weixin_45255379/article/details/141649888

版权

系列文章目录

第一章 C语言基础知识
第二章 C语言高级编程
第三章 C语言数据结构
第四章 C语言高级数据结构
第五章 C++核心编程
第六章 C++STL

前言

长久以来，软件界一直希望建立一种可重复利用的东西，以及一种得以制造出”可重复运用的东西”的方法,让程序员的心血不止于随时间的迁移，人事异动而烟消云散，从函数(functions)，类别(classes),函数库(function libraries),类别库(class libraries)、各种组件，从模块化设计，到面向对象(object oriented )，为的就是复用性的提升。为了建立数据结构和算法的一套标准，并且降低他们之间的耦合关系，以提升各自的独立性、弹性、交互操作性(相互合作性,interoperability),诞生了STL。

一、STL概论

STL基本概念：STL(Standard Template Library,标准模板库)，是惠普实验室开发的一系列软件的统称，现在主要出现在 c++中，但是在引入 c++之前该技术已经存在很长时间了。STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator),容器和算法之间通过迭代器进行无缝连接。STL 几乎所有的代码都采用了模板类或者模板函数，这相比传统的由函数和类组成的库来说提供了更好的代码重用机会。
STL六大组件简介：STL提供了六大组件，彼此之间可以组合套用，这六大组件分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器。
- 容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据，从实现角度来看，STL容器是一种class template。
- 算法：各种常用的算法，如sort、find、copy、for_each。从实现的角度来看，STL算法是一种function tempalte。
- 迭代器：扮演了容器与算法之间的胶合剂，共有五种类型，从实现角度来看，迭代器是一种将operator* , operator-> , operator++,operator–等指针相关操作予以重载的class template。所有STL容器都附带有自己专属的迭代器，只有容器的设计者才知道如何遍历自己的元素。原生指针(native pointer)也是一种迭代器。
- 仿函数：行为类似函数，可作为算法的某种策略。从实现角度来看，仿函数是一种重载了operator()的class 或者class template。
- 适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
- 空间配置器：负责空间的配置与管理。从实现角度看，配置器是一个实现了动态空间配置、空间管理、空间释放的class template。
- STL六大组件的交互关系，容器通过空间配置器取得数据存储空间，算法通过迭代器存储容器中的内容，仿函数可以协助算法完成不同的策略的变化，适配器可以修饰仿函数。
STL优点:不用额外安装什么，内建在你的编译器之内。数据和操作分离。数据由容器类别加以管理，操作则由可定制的算法定义。迭代器在两者之间充当“粘合剂”,以使算法可以和容器交互运作。程序员可以不用思考 STL 具体的实现过程，只要能够熟练使用 STL 就 OK 了。
- 高可重用性：STL 中几乎所有的代码都采用了模板类和模版函数的方式实现，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。
- 高性能：如 map 可以高效地从十万条记录里面查找出指定的记录，因为 map 是采用红黑树的变体实现的。
- 高移植性：如在项目 A 上用 STL 编写的模块，可以直接移植到项目 B 上。

二、STL三大组件

容器：STL容器就是将运用最广泛的一些数据结构实现出来。常用的数据结构：数组(array),链表(list),tree(树),栈(stack),队列(queue),集合(set),映射表(map),根据数据在容器中的排列特性，这些数据分为序列式容器和关联式容器两种。
- 序列式容器强调值的排序，序列式容器中的每个元素均有固定的位置，除非用删除或插入的操作改变这个位置。Vector容器、Deque容器、List容器等。
- 关联式容器是非线性的树结构，更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系，也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。关联式容器另一个显著特点是：在值中选择一个值作为关键字key，这个关键字对值起到索引的作用，方便查找。如set/multiset容器 map/multimap容器。
算法：STL收录的算法经过了数学上的效能分析与证明，是极具复用价值的，包括常用的排序，查找等等。特定的算法往往搭配特定的数据结构，算法与数据结构相辅相成。算法分为:质变算法和非质变算法。
- 质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等。
- 非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等。
迭代器：设计模式中的iterator模式定义如下：提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。迭代器的设计思维关键所在将容器(container)和算法(algorithms)分开，彼此独立设计，最后再一贴胶着剂将他们撮合在一起。
案例：STL容器不单单可以存储基础数据类型，也可以存储类对象。通过迭代器遍历。容器嵌套容器。

三、常用容器

1. string容器

基本概念：C++标准库定义了一种string类，定义在头文件。Char*是一个指针，String是一个类。string封装了char*，管理这个字符串，是一个char*型的容器。String封装了很多实用的成员方法：查找find，拷贝copy，删除delete 替换replace，插入insert。不用考虑内存释放和越界：string管理char*所分配的内存。每一次string的复制，取值都由string类负责维护，不用担心复制越界和取值越界等。

常用操作：构造函数、基本赋值操作、存取字符操作、拼接操作、查找和替换、比较操作、子串、插入和删除操作、string和c-style字符串转换。

//string构造函数
string();//创建一个空的字符串 例如: string str;      
string(const string& str);//使用一个string对象初始化另一个string对象
string(const char* s);//使用字符串s初始化
string(int n, char c);//使用n个字符c初始化 
//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赋给当前字符串
string& assign(const string &s, int start, int n);//将s从start开始n个字符赋值给字符串
//string存取字符操作
char& operator[](int n);//通过[]方式取字符
char& at(int n);//通过at方法获取字符
//string拼接操作
string& operator+=(const string& str);//重载+=操作符
string& operator+=(const char* str);//重载+=操作符
string& operator+=(const char c);//重载+=操作符
string& append(const char *s);//把字符串s连接到当前字符串结尾
string& append(const char *s, int n);//把字符串s的前n个字符连接到当前字符串结尾
string& append(const string &s);//同operator+=()
string& append(const string &s, int pos, int n);//把字符串s中从pos开始的n个字符连接到当前字符串结尾
string& append(int n, char c);//在当前字符串结尾添加n个字符c
//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
//string比较操作
//compare函数在>时返回 1，<时返回 -1，==时返回 0。
//比较区分大小写，比较时参考字典顺序，排越前面的越小。
//大写的A比小写的a小。
int compare(const string &s) const;//与字符串s比较
int compare(const char *s) const;//与字符串s比较
//string子串
string substr(int pos = 0, int n = npos) const;//返回由pos开始的n个字符组成的字符串
//string插入和删除操作
string& insert(int pos, const char* s); //插入字符串
string& insert(int pos, const string& str); //插入字符串
string& insert(int pos, int n, char c);//在指定位置插入n个字符c
string& erase(int pos, int n = npos);//删除从Pos开始的n个字符
//string和c-style字符串转换
//string 转 char*
string str = "itcast";
const char* cstr = str.c_str();
//char* 转 string 
char* s = "itcast";
string str(s);

在c++中存在一个从const char*到string的隐式类型转换，却不存在从一个string对象到C_string的自动类型转换。对于string类型的字符串，可以通过c_str()函数返回string对象对应的C_string。
为了修改string字符串的内容，下标操作符[]和at都会返回字符的引用。但当字符串的内存被重新分配之后，可能发生错误。
练习：写一个函数，函数内部将string字符串中的所有小写字母都变为大写字母。

2. vector容器

基本概念：vector的数据安排以及操作方式，与array非常相似，两者的唯一差别在于空间的运用的灵活性。Vector是动态空间，随着元素的加入，它的内部机制会自动扩充空间以容纳新元素。因此vector的运用对于内存的合理利用与运用的灵活性有很大的帮助。
vector的空间配置策略：一旦vector旧空间满了，如果客户每新增一个元素，vector内部只是扩充一个元素的空间，实为不智，其加入某种未雨绸缪的考虑。
vector迭代器：Vector维护一个线性空间，所以不论元素的型别如何，普通指针都可以作为vector的迭代器，因为vector迭代器所需要的操作行为，如operator*, operator->, operator++, operator–, operator+, operator-, operator+=, operator-=, 普通指针天生具备。所以vector提供的是随机访问迭代器(Random Access Iterators)。
vector的数据结构：线性连续空间，它以两个迭代器Myfirst和Mylast分别指向配置得来的连续空间中目前已被使用的范围，并以迭代器Myend指向整块连续内存空间的尾端。为了降低空间配置时的速度成本，vector实际配置的大小可能比客户端需求大一些，以备将来可能的扩充，这就是容量的概念。一个vector的容量永远大于或等于其大小，一旦容量等于大小，便是满载，下次再有新增元素，整个vector容器就得另觅居所。
- 所谓动态增加大小，并不是在原空间之后续接新空间(因为无法保证原空间之后尚有可配置的空间)，而是一块更大的内存空间，然后将原数据拷贝新空间，并释放原空间。因此，对vector的任何操作，一旦引起空间的重新配置，指向原vector的所有迭代器就都失效了。

常用操作：构造函数、基本赋值操作、大小操作、数据存取操作、插入和删除操作。

//vector构造函数
vector<T> v; //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end());//将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem);//构造函数将n个elem拷贝给本身。
vector(const vector &vec);//拷贝构造函数。
//vector常用赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
vector& operator=(const vector  &vec);//重载等号操作符
swap(vec);// 将vec与本身的元素互换。
//vector大小操作
size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
resize(int num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长>度的元素被删除。
capacity();//容器的容量
reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。
//vector数据存取操作
at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。
operator[];//返回索引idx所指的数据，越界时，运行直接报错
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素
//vector插入和删除操作
insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素ele.
push_back(ele); //尾部插入元素ele
pop_back();//删除最后一个元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
erase(const_iterator pos);//删除迭代器指向的元素
clear();//删除容器中所有元素

vector小案例：巧用swap，收缩内存空间。reserve预留空间。

3. deque容器

基本概念：Vector容器是单向开口的连续内存空间，deque则是一种双向开口的连续线性空间。双向开口，意思是可以在头尾两端分别做元素的插入和删除操作，当然，vector容器也可以在头尾两端插入元素，但是在其头部操作效率奇差，无法被接受。
Deque容器和vector容器的差异：一在于deque允许使用常数项时间对头端进行元素的插入和删除操作。二在于deque没有容量的概念，因为它是动态的以分段连续空间组合而成，随时可以增加一段新的空间并链接起来，因此deque没有必须要提供所谓的空间保留(reserve)功能。
deque容器也提供了Random Access Iterator,但是它的迭代器并不是普通的指针，其复杂度和vector不是一个量级，这影响了各个运算的层面。因此，除非有必要，我们应该尽可能的使用vector，而不是deque。对deque进行的排序操作，为了最高效率，可将deque先完整的复制到一个vector中，对vector容器进行排序，再复制回deque。
deque容器实现原理：array无法成长，vector虽可成长，却只能向尾端成长，而且其成长其实是一个假象，事实上(1) 申请更大空间 (2)原数据复制新空间 (3)释放原空间三步骤。Deque是由一段一段的定量的连续空间构成。一旦有必要在deque前端或者尾端增加新的空间，便配置一段连续定量的空间，串接在deque的头端或者尾端。Deque最大的工作就是维护这些分段连续的内存空间的整体性的假象，并提供随机存取的接口，避开了重新配置空间，复制，释放的轮回，代价就是复杂的迭代器架构。Deque采取一块所谓的map(注意，不是STL的map容器)作为主控，这里所谓的map是一小块连续的内存空间，其中每一个元素(此处成为一个结点)都是一个指针，指向另一段连续性内存空间，称作缓冲区。缓冲区才是deque的存储空间的主体。

常用操作：构造函数、赋值操作、大小操作、双端插入和删除操作、数据存取、插入操作、删除操作。

//deque构造函数
deque<T> deqT;//默认构造形式
deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n, elem);//构造函数将n个elem拷贝给本身。
deque(const deque &deq);//拷贝构造函数。
//deque赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
deque& operator=(const deque &deq); //重载等号操作符 
swap(deq);// 将deq与本身的元素互换
//deque大小操作
deque.size();//返回容器中元素的个数
deque.empty();//判断容器是否为空
deque.resize(num);//重新指定容器的长度为num,若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置,如果容器变短，则末尾超出容器长度的元素被删除。
//deque双端插入和删除操作
push_back(elem);//在容器尾部添加一个数据
push_front(elem);//在容器头部插入一个数据
pop_back();//删除容器最后一个数据
pop_front();//删除容器第一个数据
//deque数据存取
at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range。
operator[];//返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
front();//返回第一个数据。
back();//返回最后一个数据
//deque插入操作
insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
//deque删除操作
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除pos位置的数据，返回下一个数据的位置。

案例：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。

4. list容器

基本概念：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
List容器是一个双向链表。采用动态存储分配，不会造成内存浪费和溢出。链表执行插入和删除操作十分方便，l永远是常数时间，修改指针即可，不需要移动大量元素。链表灵活，但是空间和时间额外耗费较大。
list容器的迭代器：由于list是一个双向链表，迭代器必须能够具备前移、后移的能力，所以list容器提供的是Bidirectional Iterators。List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效。这在vector是不成立的，因为vector的插入操作可能造成记忆体重新配置，导致原有的迭代器全部失效，甚至List元素的删除，也只有被删除的那个元素的迭代器失效，其他迭代器不受任何影响。
list容器的数据结构：list容器不仅是一个双向链表，而且还是一个循环的双向链表。验证list容器是循环双向链表。

常用操作：构造函数、元素插入和删除操作、大小操作、赋值操作、数据的存取、反转排序。

//list构造函数
list<T> lstT;//list采用采用模板类实现,对象的默认构造形式：
list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem);//构造函数将n个elem拷贝给本身。
list(const list &lst);//拷贝构造函数。
//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大小操作
size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(num);//重新指定容器的长度为num，
//若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem);//重新指定容器的长度为num，
//若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
//list赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
list& operator=(const list &lst);//重载等号操作符
swap(lst);//将lst与本身的元素互换。
//list数据的存取
front();//返回第一个元素。
back();//返回最后一个元素。
//list反转排序
reverse();//反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。
sort(); //list排序

5. set/multiset容器

基本概念：Set的特性是所有元素都会根据元素的键值自动被排序。set的元素即是键值又是实值。Set不允许两个元素有相同的键值。因为set元素值就是其键值，关系到set元素的排序规则。如果任意改变set元素值，会严重破坏set组织。set的iterator是一种const_iterator。
set拥有和list某些相同的性质，当对容器中的元素进行插入操作或者删除操作的时候，操作之前所有的迭代器，在操作完成之后依然有效，被删除的那个元素的迭代器必然是一个例外。
set拥有和list某些相同的性质，当对容器中的元素进行插入操作或者删除操作的时候，操作之前所有的迭代器，在操作完成之后依然有效，被删除的那个元素的迭代器必然是一个例外。（二叉树—二叉搜索树—二叉平衡树—红黑树）

常用操作：构造函数、赋值操作、大小操作、插入和删除操作、查找操作。

//set构造函数
set<T> st;//set默认构造函数：
mulitset<T> mst; //multiset默认构造函数: 
set(const set &st);//拷贝构造函数
//set赋值操作
set& operator=(const set &st);//重载等号操作符
swap(st);//交换两个集合容器
//set大小操作
size();//返回容器中元素的数目
empty();//判断容器是否为空
//set插入和删除操作
insert(elem);//在容器中插入元素。
clear();//清除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(elem);//删除容器中值为elem的元素。
//set查找操作
find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key);//查找键key的元素个数
lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。

set容器的第二个模板参数可以设置排序规则，默认规则是less<_Kty>。

对组(pair)：将一对值组合成一个值，这一对值可以具有不同的数据类型，两个值可以分别用pair的两个公有属性first和second访问。

//第一种方法创建一个对组
pair<string, int> pair1(string("name"), 20);
cout << pair1.first << endl; //访问pair第一个值
cout << pair1.second << endl;//访问pair第二个值
//第二种
pair<string, int> pair2 = make_pair("name", 30);
cout << pair2.first << endl;
cout << pair2.second << endl;
//pair=赋值
pair<string, int> pair3 = pair2;
cout << pair3.first << endl;
cout << pair3.second << endl;

6. map/multimap容器

基本概念：Map的特性是，所有元素都会根据元素的键值自动排序。Map所有的元素都是pair,同时拥有实值和键值，pair的第一元素被视为键值，第二元素被视为实值，map不允许两个元素有相同的键值。因为map的键值关系到map元素的排列规则，任意改变map键值将会严重破坏map组织。如果想要修改元素的实值，那么是可以的。
Map和list拥有相同的某些性质，当对它的容器元素进行新增操作或者删除操作时，操作之前的所有迭代器，在操作完成之后依然有效，当然被删除的那个元素的迭代器必然是个例外。
Multimap和map的操作类似，唯一区别multimap键值可重复。Map和multimap都是以红黑树为底层实现机制。

常用操作：构造函数、赋值操作、大小操作、插入和删除操作、查找操作。

//map构造函数
map<T1, T2> mapTT;//map默认构造函数: 
map(const map &mp);//拷贝构造函数
//map赋值操作
map& operator=(const map &mp);//重载等号操作符
swap(mp);//交换两个集合容器
//map大小操作
size();//返回容器中元素的数目
empty();//判断容器是否为空
//map插入数据元素操作
map.insert(...); //往容器插入元素，返回pair<iterator,bool>
map<int, string> mapStu;
// 第一种 通过pair的方式插入对象
mapStu.insert(pair<int, string>(3, "小张"));
// 第二种 通过pair的方式插入对象
mapStu.inset(make_pair(-1, "校长"));
// 第三种 通过value_type的方式插入对象
mapStu.insert(map<int, string>::value_type(1, "小李"));
// 第四种 通过数组的方式插入值
mapStu[3] = "小刘";
mapStu[5] = "小王";
//map删除操作
clear();//删除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg,end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(keyElem);//删除容器中key为keyElem的对组。
// map查找操作
find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；/若不存在，返回map.end();
count(keyElem);//返回容器中key为keyElem的对组个数。对map来说，要么是0，要么是1。对multimap来说，值可能大于1。
lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。

multimap案例：公司招聘了5个员工，5名员工进入公司之后，需要指派员工在那个部门工作。

7. STL容器使用时机

vector的使用场景：比如软件历史操作记录的存储，我们经常要查看历史记录，比如上一次的记录，上上次的记录，但却不会去删除记录，因为记录是事实的描述。
deque的使用场景：比如排队购票系统，对排队者的存储可以采用deque，支持头端的快速移除，尾端的快速添加。如果采用vector，则头端移除时，会移动大量的数据，速度慢。 vector与deque的比较：
- vector.at()比deque.at()效率高，比如vector.at(0)是固定的，deque的开始位置却是不固定的。
- 如果有大量释放操作的话，vector花的时间更少，这跟二者的内部实现有关。
- deque支持头部的快速插入与快速移除，这是deque的优点。
list的使用场景：比如公交车乘客的存储，随时可能有乘客下车，支持频繁的不确实位置元素的移除插入。
set的使用场景：比如对手机游戏的个人得分记录的存储，存储要求从高分到低分的顺序排列。
map的使用场景：比如按ID号存储十万个用户，想要快速要通过ID查找对应的用户。二叉树的查找效率，这时就体现出来了。如果是vector容器，最坏的情况下可能要遍历完整个容器才能找到该用户。

四、常用算法

1. 函数对象

重载函数调用操作符的类，其对象常称为函数对象（function object），即它们是行为类似函数的对象，也叫仿函数(functor),其实就是重载“()”操作符，使得类对象可以像函数那样调用。是一个类，不是一个函数。重载的operator()要求获取一个参数，我们就将这个类称为“一元仿函数”（unary functor）；相反，如果重载的operator()要求获取两个参数，就将这个类称为“二元仿函数”（binary functor）。
- 函数对象通常不定义构造函数和析构函数，所以在构造和析构时不会发生任何问题，避免了函数调用的运行时问题。
- 函数对象超出了普通函数的概念，可以保存函数的调用状态。
- 函数对象可内联编译，性能好。用函数指针几乎不可能。
- 模版函数对象使函数对象具有通用性，这也是它的优势之一。
谓词是指普通函数或重载的operator()返回值是bool类型的函数对象(仿函数)。如果operator接受一个参数，那么叫做一元谓词,如果接受两个参数，那么叫做二元谓词，谓词可作为一个判断式。

STL内建了一些函数对象。分为:算数类函数对象,关系运算类函数对象，逻辑运算类仿函数。这些仿函数所产生的对象，用法和一般函数完全相同，当然我们还可以产生无名的临时对象来履行函数功能。使用内建函数对象，需要引入头文件 #include。

//6个算数类函数对象,除了negate是一元运算，其他都是二元运算
template<class T> T plus<T>//加法仿函数
template<class T> T minus<T>//减法仿函数
template<class T> T multiplies<T>//乘法仿函数
template<class T> T divides<T>//除法仿函数
template<class T> T modulus<T>//取模仿函数
template<class T> T negate<T>//取反仿函数
//6个关系运算类函数对象,每一种都是二元运算。
template<class T> bool equal_to<T>//等于
template<class T> bool not_equal_to<T>//不等于
template<class T> bool greater<T>//大于
template<class T> bool greater_equal<T>//大于等于
template<class T> bool less<T>//小于
template<class T> bool less_equal<T>//小于等于
//逻辑运算类运算函数,not为一元运算，其余为二元运算。
template<class T> bool logical_and<T>//逻辑与
template<class T> bool logical_or<T>//逻辑或
template<class T> bool logical_not<T>//逻辑非

函数对象适配器:在遍历容器的时候，希望将容器中的值全部加上100之后显示出来，怎么做？直接给函数对象绑定参数编译阶段就会报错。for_each(v.begin(), v.end(), bind2nd(myprint(),100));如果我们想使用绑定适配器,需要我们自己的函数对象继承binary_function 或者 unary_function根据我们函数对象是一元函数对象还是二元函数对象。
- bind1st ：将参数绑定为函数对象的第一个参数。bind2nd ：将参数绑定为函数对象的第二个参数。bind1st，bind2nd将二元函数对象转为一元函数对象。
- ptr_fun( )把一个普通的函数指针适配成函数对象。如果容器存放的是对象指针，那么用mem_fun，如果容器中存放的是对象实体，那么用mem_fun_ref。

2. 算法概述

算法主要是由头文件<algorithm> <functional> <numeric>组成。
<algorithm>是所有STL头文件中最大的一个,其中常用的功能涉及到比较，交换，查找,遍历，复制，修改，反转，排序，合并等…
<numeric>体积很小，只包括在几个序列容器上进行的简单运算的模板函数。
<functional> 定义了一些模板类,用以声明函数对象。

3. 常用遍历算法

常用遍历算法：for_each 遍历算法遍历容器元素，transform 将指定容器区间元素搬运到另一容器中。注：transform不会给目标容器分配内存，所以需要我们提前分配好内存。

for_each(iterator beg, iterator end, _callback);
//开始迭代器、结束迭代器、函数回调或者函数对象、return函数对象

transform(iterator beg1, iterator end1, iterator beg2, _callbakc);
//源容器开始迭代器、源容器结束迭代器、目标容器开始迭代器、回调函数或者函数对象、返回目标容器迭代器

4. 常用查找算法

常用查找算法：find算法查找元素，find_if算法条件查找，adjacent_find算法查找相邻重复元素，binary_search算法二分查找法，在无序序列中不可用，count算法统计元素出现次数，count_if算法统计元素出现次数。

find(iterator beg, iterator end, value);
//开始迭代器、结束迭代器、查找的元素、返回查找元素的位置

find_if(iterator beg, iterator end, _callback);
//开始迭代器、结束迭代器、回调函数或者谓词(返回bool类型的函数对象)、查找返回true 否则false

adjacent_find(iterator beg, iterator end, _callback);
//开始迭代器、结束迭代器、回调函数或者谓词(返回bool类型的函数对象)、返回相邻元素的第一个位置的迭代器

bool binary_search(iterator beg, iterator end, value);
//开始迭代器、结束迭代器、查找的元素、查找返回true,否则false

count(iterator beg, iterator end, value);
//开始迭代器、结束迭代器、回调函数或者谓词(返回bool类型的函数对象)、返回元素个数

count_if(iterator beg, iterator end, _callback);
//开始迭代器、结束迭代器、回调函数或者谓词(返回bool类型的函数对象)、返回元素个数

5. 常用排序算法

常用排序算法：merge算法容器元素合并，并存储到另一容器中，sort算法容器元素排序，random_shuffle算法对指定范围内的元素随机调整次序，reverse算法反转指定范围的元素。

merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
//容器1开始迭代器、容器1结束迭代器、容器2开始迭代器、容器2结束迭代器、目标容器开始迭代器  两个容器必须是有序的

sort(iterator beg, iterator end, _callback);
//开始迭代器、结束迭代器、回调函数或者谓词(返回bool类型的函数对象)

random_shuffle(iterator beg, iterator end);
//开始迭代器、结束迭代器

reverse(iterator beg, iterator end);
//开始迭代器、结束迭代器

6. 常用拷贝和替换算法

常用拷贝和替换算法:copy算法将容器内指定范围的元素拷贝到另一容器中，replace算法将容器内指定范围的旧元素修改为新元素，replace_if算法将容器内指定范围满足条件的元素替换为新元素，swap算法互换两个容器的元素。

copy(iterator beg, iterator end, iterator dest);
//开始迭代器、结束迭代器、目标起始迭代器

replace(iterator beg, iterator end, oldvalue, newvalue);
//开始迭代器、结束迭代器、旧元素、新元素

replace_if(iterator beg, iterator end, _callback, newvalue);
//开始迭代器、结束迭代器、回调函数或者谓词(返回bool类型的函数对象)、新元素

swap(container c1, container c2);
//容器1、容器2

copy实现打印：copy(v.begin(),v.end() , ostream_iterator<int>(cout , “ ”));

7. 常用算数生成算法

常用算数生成算法：accumulate算法计算容器元素累计总和，fill算法向容器中添加元素。

accumulate(iterator beg, iterator end, value);
//开始迭代器、结束迭代器、累加值

fill(iterator beg, iterator end, value);
//开始迭代器、结束迭代器、填充元素

8. 常用集合算法

常用集合算法：set_intersection算法求两个set集合的交集，set_union算法求两个set集合的并集，set_union算法求两个set集合的并集。注意:两个集合必须是有序序列。

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
//开始迭代器、结束迭代器、容器2开始迭代器、容器2结束迭代器、目标容器开始迭代器、返回目标容器的最后一个元素的迭代器地址

set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
//开始迭代器、结束迭代器、容器2开始迭代器、容器2结束迭代器、目标容器开始迭代器、返回目标容器的最后一个元素的迭代器地址

set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
//开始迭代器、结束迭代器、容器2开始迭代器、容器2结束迭代器、目标容器开始迭代器、返回目标容器的最后一个元素的迭代器地址

五、STL综合案例(学校演讲比赛)

比赛规则：学校举行一场演讲比赛，共有12个人参加。比赛共两轮，第一轮为淘汰赛，第二轮为决赛。比赛方式：分组比赛，每组6个人；选手每次要随机分组，进行比赛每名选手都有对应的编号，如 10001 ~ 10012 。第一轮分为两个小组，每组6个人。整体按照选手编号进行抽签后顺序演讲。当小组演讲完后，淘汰组内排名最后的三个选手，前三名晋级，进入下一轮的比赛。第二轮为决赛，前三名胜出每轮比赛过后需要显示晋级选手的信息。
比赛评分：10个评委打分，去除最低、最高分，求平均分每个选手演讲完由10个评委分别打分。该选手的最终得分是去掉一个最高分和一个最低分，求得剩下的8个成绩的平均分。选手的名次按得分降序排列。
需求分析：产生选手（ ABCDEFGHIJKLMNOPQRSTUVWX ）姓名、得分，选手编号；第1轮选手抽签选手比赛查看比赛结果；第2轮选手抽签选手比赛查看比赛结果。
实现思路：需要把选手信息、选手得分信息、选手比赛抽签信息、选手的晋级信息保存在容器中，需要涉及到各个容器的选型。
1. 选手可以设计一个类Speaker（姓名和得分）。所有选手的编号可以单独放在一个vector容器中，做抽签用。所有选手编号和选手信息，可以放在容器内：map<int, Speaker>。
2. 所有选手的编号名单，可以放在容器：vecter<int> v1中，第1轮晋级编号名单，可以放在容器vecter<int> v2中，第2轮晋级编号名单，可以放在容器vecter<int> v3中。
3. 每个小组的比赛得分信息，按照从大到小的顺序放在multimap<成绩, 编号, greater<int>>中。
4. 每个选手的得分，可以放在容器deque<int> dscore中方便去除最低最高分。
5. 最后加入随机数种子。

六、PK小游戏案例

游戏规则：玩家上来选择人物、武器，接下来由系统随机分配一个敌人进行PK。每轮PK的数据显示到屏幕中，并由玩家点击任意键进行下一轮PK。当有任意一方出现扑街，视为游戏结束。并提示胜利者。
游戏元素：玩家、敌人、武器以及文件管理。玩家手里拿的武器，特殊武器会具有不同的特殊效果，如暴击、冰冻、吸血等。文件管理
用于和文件进行沟通，本案例中的数据来源于.CSV文件，当然里面的数值由开发人员制定。
游戏制作：CSV文件制作、创建项目、解析文件、创建武器类、英雄类实现、怪物类实现、战斗实现。
- CSV文件制作：Execel中创建Hero英雄表，加入英雄属性字段（英雄ID、英雄名称、英雄血量、英雄攻击力、英雄防御力、英雄简介）。Monsters表（怪物Id、怪物名称、怪物攻击力、怪物防御力、怪物血量）。Weapons表（武器Id、武器名称、武器攻击力、武器暴击系数、武器暴击率、武器吸血系数、武器吸血率、武器冰冻率）。然后另存为.csv文件格式。
- 解析文件：创建文件管理类，封装一个方法loadCSVData，因为表中有多个英雄，所以数据读取利用二级的map来访问具体的英雄了，map<string , map<string,string>> M 大map中的第一个string为英雄的id，第二个value就是具体的英雄字段了。读数据利用C++中的文件流进行读取操作，读取的第一行字段利用了逗号进行拼接，所以我们需要分割字符串，并且可以将分割的数据放入到vector容器中，之后解析其他数据，并且放入到大容器中。
- 创建武器类：利用多态来创建一个抽象类（Weapon），这个类中不实现任何函数，只是做声明，而在他的子类中做实现操作，每把武器我们都可以单独作为一个类。
- 英雄类实现：英雄有自己的名称、攻击力、防御力等属性，以及攻击怪物，穿戴装备等行为。
- 怪物类实现：怪物除了有攻防血基本属性，我们应该额外加一个是否被冰冻的属性，来判断怪物自身的状态。
- 战斗实现：所有的角色类都设计好后，就差和用户进行交互了，在入口函数中我们可以添加战斗函数，来进行最后一步的实现。
- 最后加入随机数种子，随机出一个敌人与玩家战斗。