STL之容器
STL 概述
长久以来,软件界一直希望建立一种可重复利用的东西,以及一种得以制造出"可重复运用的东西"的方法,让程序员的心血不止于随时间的迁移,人事异动而烟消云散,从函数(functions),类别(classes),函数库(function libraries),类别库(classlibraries)、各种组件,从模块化设计,到面向对象(object oriented),为的就是复用性的提升。
复用性必须建立在某种标准之上。但是在许多环境下,就连软件开发最基本的数据结构(data structures)和算法(algorithm)都未能有一套标准。大量程序员被迫从事大量重复的工作,竟然是为了完成前人已经完成而自己手上并未拥有的程序代码,这不仅是人力资源的浪费,也是挫折与痛苦的来源。
为了建立数据结构和算法的一套标准,并且降低他们之间的耦合关系,以提升各自的独立性、弹性、交互操作性(相互合作性,interoperability),诞生了 STL
STL的基本概念
STL(Standard Template Library,标准模板库),是惠普实验室开发的一系列软件的统称。现在主要出现在c++中,但是在引入c++之前该技术已经存在很长时间了。STL从广义上分为:容器(container)算法(algorithm)迭代器(iterator),容器和算法之间通过迭代器进行无缝连接。STL几乎所有的代码都采用了模板类或者模板函数,这相比传统的由函数和类组成的库来说提供了更好的代码重用机会。
STL(Standard Template Library)标准模板库,在我们 c++标准程序库中隶属于STL的占到了80%以上。
STL的六大组件
六大组件:
1容器: 存放数据
2算法: 操作数据
3迭代器: 算法 只能借助迭代器 操作容器数据
4仿函数: 为算法提供更多的策略
5适配器(配接器): 为算法提供更多参数的接口
6空间配置器: 为算法和容器 动态分配, 管理空间
STL的一个重要特性是将`数据和操作分离, 数据由容器类别加以管理, 操作由特定的算法完成.
算法分为:
质变算法: 运算过程中更改区间内的元素内容. (拷贝, 替换, 删除等)
非质变算法: 运算过程中不会更改区间内的元素内容.(查找, 计数, 遍历, 寻找极值等)
string类
string容器的基本概念
C 风格字符串（以空字符结尾的字符数组）太过复杂难于掌握，不适合大程序的开发，所以 C++标准库定义了一种 string 类，定义在头件。
String 和 c 风格字符串对比：
Char *是一个指针，String 是一个类
string 封装了 char*，管理这个字符串，是一个 char 型的容器。
String 封装了很多实用的成员方法
查找 find，拷贝 copy，删除 delete 替换 replace，插入 insert
不用考虑内存释放和越界
string 管理 char*所分配的内存。每一次 string 的复制，取值都由 string 类负责维护，不用担心复制越界和取值越界等。
string 容器常用操作
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获取字符
[]越界不会抛出异常, 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
查找和替换
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 比较操作
int compare(const string &s) const; //与字符串s比较
int compare(const char *s) const; //与字符串s比较
> 返回 1, < 返回 -1, == 返回 0
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);
vector 容器
vector 容器的概述
vector 的数据安排以及操作方式,与 array非常相似,两者的唯一差别在于空间的运用的灵活性。Array是静态空间,一旦配置了就不能改变,要换大一点或者小一点的空间,可以,一切琐碎得由自己来,首先配置一块新的空间,然后将旧空间的数据搬往新空间,再释放原来的空间。Vector 是动态空间，随着元素的加入，它的内部机制会自动扩充空间以容纳新元素。因此 vector 的运用对于内存的合理利用与运用的灵活性有很大的帮助,我们再也不必害怕空间不足而一开始就要求一个大块头的array 了。Vector的实现技术,关键在于其对大小的控制以及重新配置时的数据移动效率，一旦 vector 旧空间满了，如果客户每新增一个元素，vector内部只是扩充一个元素的空间，实为不智，因为所谓的扩充空间(不论多大),一如刚所说，是"配置新空间-数据移动-释放旧空间"的大工程,时间成本很高，应该加入某种未雨绸缪的考虑，稍后我们便可以看到 vector 的空间配置策略。
v.begin(): 获取容器的起始迭代器(指向第0个元素)
v.end()获取容器的结束迭代器(指向最后一个元素的下一个位置)
vector 常用API操作
vector 构造函数
vector<T> v；//采用模板实现类实现，默认构造函数
vector(v.begin()， v.end())；//将 v[begin()， end())区间中的元素拷贝给本身。
vector(n, elem);//构造函数将 n个elem拷贝给本身。
vector(const vector &vec);//拷贝构造函数。
vector<int> v1;
v1.push_back(10);
v1.push_back(20);
v1.push_back(30);
v1.push_back(40);
v1.push_back(50);
//遍历容器, 定义一个迭代器iterator保存起始迭代器
vector<int>::iterator it = v1.begin();
for (;it!=v1.end();it++)
{
//*it == int
cout << *it << " ";
}
cout << endl;
vector v1;
//预留空间
v1.reserve(1000);
vector 常用赋值操作
assign(begin，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值填充新位置。如果容器变短,则末尾超出容器长>度的元l素被删除。
capacity();//容器的容量
reserve(int len);//容器预留1en个元素长度,预留位置不初始化,元素不可访问。
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();//刪除容器中所有元素
巧用swap收缩内存空间
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> v1;
v1.reserve(1000);
v1.push_back(10);
v1.push_back(20);
v1.push_back(30);
v1.push_back(40);
v1.push_back(50);
v1.push_back(60);
cout << "容量: " << v1.capacity() << ", 大小: " << v1.size() << endl;
//resize 只能修改大小, 不能修改容量
v1.resize(10);
cout << "容量: " << v1.capacity() << ", 大小: " << v1.size() << endl;
vector<int>(v1).swap(v1);
cout << "容量: " << v1.capacity() << ", 大小: " << v1.size() << endl;
return 0;
}
定义一个vector容器存放v1 v2 v3
vector<vector<int>> v;
v.push_back(v1);
v.push_back(v2);
v.push_back(v3);
//遍历
vector<vector<int>>::iterator it = v.begin();
for(;it!=v.end();it++)
{
//*it == vector<int>
vector<int>::iterator mit = (*it).begin();
for(;mit!=(*it).end();mit++)
{
//*mit == int
cout << *mit << " ";
}
cout << endl;
}
使用STL算法对vector容器排序
对基本类型排序
#include<algorithm>
void STLSort(vector<int>& v)
{
//排序
sort(v.begin(), v.end());
printVector(v);
}
对自定义类型排序
#include <iostream>
#include <vector>
using namespace std;
class Person
{
friend void printVectorPerson(vector<Person>& v);
friend bool comparePerson(Person& ob1, Person& ob2);
private:
int num;
string name;
float score;
public:
Person(){}
Person(int num, string name, float score)
{
this->num = num;
this->name = name;
this->score = score;
}
};
void printVectorPerson(vector<Person>& v)
{
vector<Person>::iterator it = v.begin();
for(;it!=v.end();it++)
{
cout << (*it).num << " " << (*it).name << " " << (*it).score << endl;;
}
}
bool comparePerson(Person& ob1, Person& ob2)
{
return ob1.num < ob2.num;
}
#include<algorithm>
int main()
{
vector<Person> v;
v.push_back(Person(105, "lucy5", 95));
v.push_back(Person(109, "lucy9", 99));
v.push_back(Person(102, "lucy2", 92));
v.push_back(Person(107, "lucy7", 97));
v.push_back(Person(101, "lucy1", 91));
printVectorPerson(v);
sort(v.begin(), v.end(), comparePerson);
cout << "============================" << endl;
printVectorPerson(v);
return 0;
}
deque 容器
deque 容器基本概念
vector容器是单向开口的连续内存空间, deque则是一种双向开口的连续线性空间。所谓的双向开口,意思是可以在头尾两端分别做元素的插入和删除操作，当然，vector 容器也可以在头尾两端插入元素，但是在其头部操作效率奇差，无法被接受
Deque容器和vector容器最大的差异,一在于deque允许使用常数项时间对头端进行元素的插入和删除操作。二在于deque没有容量的概念,因为它是动态的以分段连续空间组合而成,随时可以增加一段新的空间并链接起来,换句话说,像vector那样,"旧空间不足而重新配置一块更大空间，然后复制元素，再释放旧空间"这样的事情在deque 身上是不会发生的。也因此，deque没有必须要提供所谓的空间保留(reserve)功能.虽然deque容器也提供了Random Access Iterator,但是它的迭代器并不是普通的指针,其复杂度和vector不是一个量级,这当然影响各个运算的层面。因此,除非有必要,我们应该尽可能的使用vector,而不是deque。对deque进行的排序操作，为了最高效率，可将 deque 先完整的复制到一个vector 中，对vector 容器进行排序，再复制回deque
deque 容器实现原理
Deque容器是连续的空间,至少逻辑上看来如此,连续现行空间总是令我们联想到array和vector,array无法成长, vector虽可成长却只能向尾端成长,而且其成长其实是一个假象,事实上(1)申请更大空间(2)原数据复制新空间(3)释放原空间三步骤,如果不是vector每次配置新的空间时都留有余裕,其成长假象所带来的代价是非常昂贵的。Deque是由一段一段的定量的连续空间构成。一旦有必要在deque前端或者尾端增加新的空间,便配置一段连续定量的空间,串接在deque的头端或者尾端。Deque最大的工作就是维护这些分段连续的内存空间的整体性的假象，并提供随机存取的接口，避开了重新配置空间，复制，释放的轮回，代价就是复杂的迭代器架构。既然deque是分段连续内存空间,那么就必须有中央控制,维持整体连续的假象,数据结构的设计及迭代器的前进后退操作颇为繁琐。Deque代码的实现远比vector或list都多得多。Deque采取一块所谓的map(注意，不是STL的map容器)作为主控，这里所谓的map是一小块连续的内存空间,其中每一个元素(此处成为一个结点)都是一个指针,指向另一段连续性内存空间,称作缓冲区。缓冲区才是deque 的存储空间的主体。
deque常用api
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位置的数据,返回下一个数据的位置。
stack容器
stack容器基本概念
stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口，形式如图所示。stack容器允许新增元素,移除元素,取得栈顶元素,但是除了最顶端外,没有任何其他方法可以存取stack的其他元素。换言之,stack不允许有遍历行为。有元素推入栈的操作称为:push,将元素推出stack的操作称为 pop.
Stack所有元素的进出都必须符合"先进后出"的条件,只有stack顶端的元素,才有机会被外界取用。Stack不提供遍历功能,也不提供迭代器
stack常用API
stack 构造函数
stack<T> stkT;//stack 采用模板类实现， stack 对象的默认构造形式：
stack(const stack &stk);//拷贝构造函数
stack 赋值操作
stack& operator=(const stack &stk);//重载等号操作符
stack 数据存取操作
push(elem);//向栈顶添加元素
pop（);//从栈顶移除第一个元素
top（）；//返回栈顶元素
stack 大小操作
empty（);//判断堆栈是否为空
size();//返回堆栈的大小
queue 容器
queue容器基本概念
Queue 是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口，queue容器允许从一端新增元素，从另一端移除元素。
Queue所有元素的进出都必须符合"先进先出"的条件,只有queue的顶端元素,才有机会被外界取用。Queue不提供遍历功能,也不提供迭代器。
queue常用api
queue<T> queT;//queue采用模板类实现, queue对象的默认构造形式:
queue(const queue &que);//拷贝构造函数
push(elem);//往队尾添加元素
pop();//从队头移除第一个元素
back();//返回最后一个元素
front();//返回第一个元素
queue& operator=(const queue &que);//重载等号操作符
size();//返回队列的大小
empty（);//判断队列是否为空
list 容器
list容器基本概念
链表是一种物理存储单元上非遥续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相较于vector 的连续线性空间，list就显得负责许多，它的好处是每次插入或者删除一个元素，就是配置或者释放一个元素的空间。因此，list 对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素的移除，list永远是常数时间。List和vector是两个最常被使用的容器。List容器是一个双向链表。
采用动态存储分配，不会造成内存浪费和溢出 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素 链表灵活，但是空间和时间额外耗费较大。
list常用api
list 构造函数
list<T> 1stT;//list采用采用模板类实现，对象的默认构造形式:
list(beg，end);//构造函数将[beg，end)区间中的元素拷贝给本身。
list(n,elem);//构造函数将 n个 elem 拷贝给本身。
list(const list &lst);//拷贝构造函数。
list 数据元素插入和删除操作
push_back(elem);//在容器尾部加入一个元素
pop_backO;//删除容器中最后一个元素
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(1st);//将 Ist 与本身的元素互换。
list数据的存取
front（);//返回第一个元素。
back()；//返回最后一个元素。
list 反转排序
reverse();//反转链表，比如 1st 包含 1,3,5 元素，运行此方法后，1st 就包含 5，3,1元素。
sort(); //list 排序
set/multiset 容器
set/multiset 容器基本概念
set 的特性是。所有元素都会根据元素的键值自动被排序，set 的元素即是键值又是实值。
set 不允许两个元素有相同的键值。
set 容器的迭代器是只读迭代器, 不允许修改键值, 会破坏set的内部结构
multiset 特性及用法和 set 完全相同，唯一的差别在于它允许键值重复。
set修改排序
#include <iostream>
#include <set>
using namespace std;
//修改set排序规则
class MyGreater
{
public:
bool operator()(int v1, int v2)const
{
return v1>v2;
}
};
void printSetInt(set<int, MyGreater>& s)
{
set<int, MyGreater>::const_iterator it = s.begin();
for(;it!=s.end();it++)
{
cout << *it << " ";
}
cout << endl;
}
class MyGreaterPerson;
//set存放自定义数据必须修改排序
class Person
{
friend void printSetPerson(set<Person, MyGreaterPerson>& s);
friend class MyGreaterPerson;
private:
int num;
string name;
float score;
public:
Person(){}
Person(int num, string name, float score)
{
this->num = num;
this->name = name;
this->score = score;
}
};
class MyGreaterPerson
{
public:
bool operator()(Person ob1, Person ob2) const
{
return ob1.num > ob2.num;
}
};
void printSetPerson(set<Person, MyGreaterPerson>& s)
{
set<Person, MyGreaterPerson>::const_iterator it = s.begin();
for(;it!=s.end();it++)
{
cout << (*it).num << " " << (*it).name << " " << (*it).score << endl;
}
}
int main()
{
//基本类型修改排序
set<int, MyGreater> s;
s.insert(10);
s.insert(20);
s.insert(30);
s.insert(50);
s.insert(40);
printSetInt(s);
//自定义类型修改排序
set<Person, MyGreaterPerson> sp;
sp.insert(Person(101, "lucy1", 91));
sp.insert(Person(102, "lucy2", 92));
sp.insert(Person(103, "lucy3", 93));
sp.insert(Person(104, "lucy4", 94));
sp.insert(Person(105, "lucy5", 95));
printSetPerson(sp);
return 0;
}
set常用api
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相等的上下限的两个迭代器
#include <iostream>
#include <set>
using namespace std;
int main()
{
set<int> s;
s.insert(10);
s.insert(20);
s.insert(30);
s.insert(50);
s.insert(40);
s.insert(60);
s.insert(70);
pair<set<int>::const_iterator, set<int>::const_iterator> p;
p = s.equal_range(50);
if(p.first != s.end())
{
cout << "下限为: " << *(p.first) << endl;
}
if(p.second != s.begin())
{
cout << "上限为: " << *(p.second) << endl;
}
return 0;
}
对组(pair)
对组(pair)将一对值组合成一个值，这一对值可以具有不同的数据类型，两个值可以分别用 pair 的两个公有属性 first 和 second访问
模板: template <class T1, class T2> struct pair. 如何创建对组?
//方式一
pair<int, string> p1(10086, "移动");
pair<int, string> p2(10010, "联通");
pair<int, string> p3(10000, "电信");
//方式二(推荐)
pair<int, string> p4 = make_pair(9527, "星爷");
map/multimap 容器
map/mutimap 基本概念
Map的特性是,所有元素都会根据元素的键值自动排序。Map所有的元素都是pair,同时拥有实值和键值,pair的第一元素被视为键值,第二元素被视为实值，map 不允许两个元素有相同的键值。 我们可以通过 map 的迭代器改变 map 的键值吗？答案是不行，因为 map的键值关系到 map元素的排列规则,任意改变 map键值将会严重破坏map组织。如果想要修改元素的实值,那么是可以的。Map和list拥有相同的某些性质,当对它的容器元素进行新增操作或者删除操作时,操作之前的所有迭代器,在操作完成之后依然有效,当然被删除的那个元素的迭代器必然是个例外。Multimap和map的操作类似,唯一区别multimap键值可重复。Map和multimap都是以红黑树为底层实现机制。
map容器：每个元素都是 键值-实值 成对存储，自动根据键值排序，键值不能重复，不能修改。
#include <iostream>
#include <map>
using namespace std;
class Person
{
friend void printMapPerson(map<int, Person>& m);
private:
int num;
string name;
float score;
public:
Person(){}
Person(int num, string name, float score)
{
this->num = num;
this->name = name;
this->score = score;
}
};
void printMapPerson(map<int, Person>& m)
{
map<int, Person>::const_iterator it = m.begin();
for(;it!=m.end();it++)
{
cout << "key: " << (*it).first << ", value: " << (*it).second.num << " " << (*it).second.name << " " << (*it).second.score << endl;
}
}
int main()
{
map<int, Person> m;
//方式一
m.insert(pair<int, Person>(101, Person(101, "lucy1", 91)));
//方式二(推荐)
m.insert(make_pair(102, Person(102, "lucy2", 92)));
//方式三
m.insert(map<int, Person>::value_type(103, Person(103, "lucy3", 93)));
//方式四(危险)
m[104] = Person(104, "lucy4", 94);
printMapPerson(m);
return 0;
}
map/multimap 常用api
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相等的上下限的两个迭代器
vector 的使用场景：比如软件历史操作记录的存储，我们经常要查看历史记录，比如上一次的记录，上上次的记录，但却不会去删除记录，因为记录是事实的描述。
deque的使用场景:比如排队购票系统,对排队者的存储可以采用 deque,支持头端的快速移除,尾端的快速添加。如果采用vector,则头端移除时，会移动大量的数据，速度慢。vector 与 deque的比较:一: vector.at()比 deque.at()效率高，比如 vector.at(0)是固定的，deque 的开始位置 却是不固定的。 二：如果有大量释放操作的话，vector 花的时间更少，这跟二者的内部实现有关。
deque 支持头部的快速插入与快速移除，这是 deque 的优点。
list 的使用场景:比如公交车乘客的存储,随时可能有乘客下车,支持频繁的不确实位置元素的移除插入。
set 的使用场景：比如对手机游戏的个人得分记录的存储，存储要求从高分到低分的顺序排列。
map 的使用场景：比如按ID 号存储十万个用户,想要快速要通过 ID 查找对应的用户。二叉树的查找效率，这时就体现出来了。如果是vector 容器，最坏的情况下可能要遍历完整个容器才能找到该用户。