STL基础教程

cout << "capacity:" << v.capacity() << endl;

cout << "size:" << v.size() << endl;

//此时通过resize改变容器大小

v.resize(10);

cout << "capacity:" << v.capacity() << endl;

cout << "size:" << v.size() << endl;

//容量没有改变

vector<int>(v).swap(v);

cout << "capacity:" << v.capacity() << endl;

cout << "size:" << v.size() << endl;

system("pause");

return EXIT_SUCCESS;

//现在我有这个需求在遍历容器的时候，我希望将容器中的值全部加上100之后显示出来，怎么做？

3.2.5.2 reserve预留空间

#define _CRT_SECURE_NO_WARNINGS

#include<iostream>

#include<vector>

using namespace std;

int main(){

vector<int> v;

//预先开辟空间

v.reserve(100000);

int* pStart = NULL;

int count = 0;

for (int i = 0; i < 100000;i ++){

v.push_back(i);

if (pStart != &v[0]){

pStart = &v[0];

count++;

}

cout << "count:" << count << endl;

system("pause");

return EXIT_SUCCESS;

}

3.3 deque容器

3.3.1 deque容器基本概念

Vector容器是单向开口的连续内存空间，deque则是一种双向开口的连续线性空间。所谓的双向开口，意思是可以在头尾两端分别做元素的插入和删除操作，当然，vector容器也可以在头尾两端插入元素，但是在其头部操作效率奇差，无法被接受。

Deque容器和vector容器最大的差异，一在于deque允许使用常数项时间对头端进行元素的插入和删除操作。二在于deque没有容量的概念，因为它是动态的以分段连续空间组合而成，随时可以增加一段新的空间并链接起来，换句话说，像vector那样，”旧空间不足而重新配置一块更大空间，然后复制元素，再释放旧空间”这样的事情在deque身上是不会发生的。也因此，deque没有必须要提供所谓的空间保留(reserve)功能.

虽然deque容器也提供了Random Access Iterator,但是它的迭代器并不是普通的指针，其复杂度和vector不是一个量级，这当然影响各个运算的层面。因此，除非有必要，我们应该尽可能的使用vector，而不是deque。对deque进行的排序操作，为了最高效率，可将deque先完整的复制到一个vector中，对vector容器进行排序，再复制回deque.

3.3.2 deque容器实现原理

Deque容器是连续的空间，至少逻辑上看来如此，连续现行空间总是令我们联想到array和vector,array无法成长，vector虽可成长，却只能向尾端成长，而且其成长其实是一个假象，事实上(1) 申请更大空间 (2)原数据复制新空间 (3)释放原空间三步骤，如果不是vector每次配置新的空间时都留有余裕，其成长假象所带来的代价是非常昂贵的。

Deque是由一段一段的定量的连续空间构成。一旦有必要在deque前端或者尾端增加新的空间，便配置一段连续定量的空间，串接在deque的头端或者尾端。Deque最大的工作就是维护这些分段连续的内存空间的整体性的假象，并提供随机存取的接口，避开了重新配置空间，复制，释放的轮回，代价就是复杂的迭代器架构。

既然deque是分段连续内存空间，那么就必须有中央控制，维持整体连续的假象，数据结构的设计及迭代器的前进后退操作颇为繁琐。Deque代码的实现远比vector或list都多得多。

Deque采取一块所谓的map(注意，不是STL的map容器)作为主控，这里所谓的map是一小块连续的内存空间，其中每一个元素(此处成为一个结点)都是一个指针，指向另一段连续性内存空间，称作缓冲区。缓冲区才是deque的存储空间的主体。

3.3.3 deque常用API

3.3.3.1 deque构造函数

deque<T> deqT;//默认构造形式

deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。

deque(n, elem);//构造函数将n个elem拷贝给本身。

deque(const deque &deq);//拷贝构造函数。

3.3.3.2 deque赋值操作

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。

assign(n, elem);//将n个elem拷贝赋值给本身。

deque& operator=(const deque &deq); //重载等号操作符

swap(deq);// 将deq与本身的元素互换

3.3.3.3 deque大小操作

deque.size();//返回容器中元素的个数

deque.empty();//判断容器是否为空

deque.resize(num);//重新指定容器的长度为num,若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置,如果容器变短，则末尾超出容器长度的元素被删除。

3.3.3.4 deque双端插入和删除操作

push_back(elem);//在容器尾部添加一个数据

push_front(elem);//在容器头部插入一个数据

pop_back();//删除容器最后一个数据

pop_front();//删除容器第一个数据

3.3.3.5 deque数据存取

at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range。

operator[];//返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。

front();//返回第一个数据。

back();//返回最后一个数据

3.3.3.6 deque插入操作

insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置。

insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。

insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。

3.3.3.7 deque删除操作

clear();//移除容器的所有数据

erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。

erase(pos);//删除pos位置的数据，返回下一个数据的位置。

3.3.3.8 案例（作业）

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

//1. 创建五名选手，放到vector中

//2. 遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中

//3. sort算法对deque容器中分数排序，pop_back pop_front去除最高和最低分

//4. deque容器遍历一遍，累加分数，累加分数/d.size()

//5. person.score = 平均分

3.4 stack容器

3.4.1 stack容器基本概念

stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口，形式如图所示。stack容器允许新增元素，移除元素，取得栈顶元素，但是除了最顶端外，没有任何其他方法可以存取stack的其他元素。换言之，stack不允许有遍历行为。

有元素推入栈的操作称为:push,将元素推出stack的操作称为pop.

3.4.2 stack没有迭代器

Stack所有元素的进出都必须符合”先进后出”的条件，只有stack顶端的元素，才有机会被外界取用。Stack不提供遍历功能，也不提供迭代器。

3.4.3 stack常用API

3.4.3.1 stack构造函数

stack<T> stkT;//stack采用模板类实现， stack对象的默认构造形式：

stack(const stack &stk);//拷贝构造函数

3.4.3.2 stack赋值操作

stack& operator=(const stack &stk);//重载等号操作符

3.4.3.3 stack数据存取操作

push(elem);//向栈顶添加元素

pop();//从栈顶移除第一个元素

top();//返回栈顶元素

3.4.3.4 stack大小操作

empty();//判断堆栈是否为空

size();//返回堆栈的大小

3.5 queue容器

3.5.1 queue容器基本概念

Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口，queue容器允许从一端新增元素，从另一端移除元素。

3.5.2 queue没有迭代器

Queue所有元素的进出都必须符合”先进先出”的条件，只有queue的顶端元素，才有机会被外界取用。Queue不提供遍历功能，也不提供迭代器。

3.5.3 queue常用API

3.5.3.1 queue构造函数

queue<T> queT;//queue采用模板类实现，queue对象的默认构造形式：

queue(const queue &que);//拷贝构造函数

3.5.3.2 queue存取、插入和删除操作

push(elem);//往队尾添加元素

pop();//从队头移除第一个元素

back();//返回最后一个元素

front();//返回第一个元素

3.5.3.3 queue赋值操作

queue& operator=(const queue &que);//重载等号操作符

3.5.3.4 queue大小操作

empty();//判断队列是否为空

size();//返回队列的大小

3.6 list容器

3.6.1 list容器基本概念

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

相较于vector的连续线性空间，list就显得负责许多，它的好处是每次插入或者删除一个元素，就是配置或者释放一个元素的空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素的移除，list永远是常数时间。

List和vector是两个最常被使用的容器。

List容器是一个双向链表。

n 采用动态存储分配，不会造成内存浪费和溢出

n 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

n 链表灵活，但是空间和时间额外耗费较大

3.6.2 list容器的迭代器

List容器不能像vector一样以普通指针作为迭代器，因为其节点不能保证在同一块连续的内存空间上。List迭代器必须有能力指向list的节点，并有能力进行正确的递增、递减、取值、成员存取操作。所谓”list正确的递增，递减、取值、成员取用”是指，递增时指向下一个节点，递减时指向上一个节点，取值时取的是节点的数据值，成员取用时取的是节点的成员。

由于list是一个双向链表，迭代器必须能够具备前移、后移的能力，所以list容器提供的是Bidirectional Iterators.

List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效。这在vector是不成立的，因为vector的插入操作可能造成记忆体重新配置，导致原有的迭代器全部失效，甚至List元素的删除，也只有被删除的那个元素的迭代器失效，其他迭代器不受任何影响。

3.6.3 list容器的数据结构

list容器不仅是一个双向链表，而且还是一个循环的双向链表。

#define _CRT_SECURE_NO_WARNINGS

#include<iostream>

#include<list>

using namespace std;

int main(){

list<int> myList;

for (int i = 0; i < 10; i ++){

myList.push_back(i);

}

list<int>::_Nodeptr node = myList._Myhead->_Next;

for (int i = 0; i < myList._Mysize * 2;i++){

cout << "Node:" << node->_Myval << endl;

node = node->_Next;

if (node == myList._Myhead){

node = node->_Next;

}

system("pause");

return EXIT_SUCCESS;

}

3.6.4 list常用API

3.6.4.1 list构造函数

list<T> lstT;//list采用采用模板类实现,对象的默认构造形式：

list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。

list(n,elem);//构造函数将n个elem拷贝给本身。

list(const list &lst);//拷贝构造函数。

3.6.4.2 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值匹配的元素。

3.6.4.3 list大小操作

size();//返回容器中元素的个数

empty();//判断容器是否为空

resize(num);//重新指定容器的长度为num，

若容器变长，则以默认值填充新位置。

如果容器变短，则末尾超出容器长度的元素被删除。

resize(num, elem);//重新指定容器的长度为num，

若容器变长，则以elem值填充新位置。

如果容器变短，则末尾超出容器长度的元素被删除。

3.6.4.4 list赋值操作

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。

assign(n, elem);//将n个elem拷贝赋值给本身。

list& operator=(const list &lst);//重载等号操作符

swap(lst);//将lst与本身的元素互换。

3.6.4.5 list数据的存取

front();//返回第一个元素。

back();//返回最后一个元素。

3.6.4.6 list反转排序

reverse();//反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。

sort(); //list排序

3.7 set/multiset容器

3.7.1 set/multiset容器基本概念

3.7.1.1 set容器基本概念

Set的特性是。所有元素都会根据元素的键值自动被排序。Set的元素不像map那样可以同时拥有实值和键值，set的元素即是键值又是实值。Set不允许两个元素有相同的键值。

我们可以通过set的迭代器改变set元素的值吗？不行，因为set元素值就是其键值，关系到set元素的排序规则。如果任意改变set元素值，会严重破坏set组织。换句话说，set的iterator是一种const_iterator.

set拥有和list某些相同的性质，当对容器中的元素进行插入操作或者删除操作的时候，操作之前所有的迭代器，在操作完成之后依然有效，被删除的那个元素的迭代器必然是一个例外。

3.7.1.2 multiset容器基本概念

multiset特性及用法和set完全相同，唯一的差别在于它允许键值重复。set和multiset的底层实现是红黑树，红黑树为平衡二叉树的一种。

树的简单知识：

二叉树就是任何节点最多只允许有两个字节点。分别是左子结点和右子节点。

二叉树示意图

二叉搜索树，是指二叉树中的节点按照一定的规则进行排序，使得对二叉树中元素访问更加高效。二叉搜索树的放置规则是：任何节点的元素值一定大于其左子树中的每一个节点的元素值，并且小于其右子树的值。因此从根节点一直向左走，一直到无路可走，即得到最小值，一直向右走，直至无路可走，可得到最大值。那么在儿茶搜索树中找到最大元素和最小元素是非常简单的事情。下图为二叉搜索树：

上面我们介绍了二叉搜索树，那么当一个二叉搜索树的左子树和右子树不平衡的时候，那么搜索依据上图表示，搜索9所花费的时间要比搜索17所花费的时间要多，由于我们的输入或者经过我们插入或者删除操作，二叉树失去平衡，造成搜索效率降低。

所以我们有了一个平衡二叉树的概念，所谓的平衡不是指的完全平衡。

RB-tree(红黑树)为二叉树的一种。

3.7.2 set常用API

3.7.2.1 set构造函数

set<T> st;//set默认构造函数：

mulitset<T> mst; //multiset默认构造函数:

set(const set &st);//拷贝构造函数

3.7.2.2 set赋值操作

set& operator=(const set &st);//重载等号操作符

swap(st);//交换两个集合容器

3.7.2.3 set大小操作

size();//返回容器中元素的数目

empty();//判断容器是否为空

3.7.2.4 set插入和删除操作

insert(elem);//在容器中插入元素。

clear();//清除所有元素

erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。

erase(beg, end);//删除区间[beg,end)的所有元素，返回下一个元素的迭代器。

erase(elem);//删除容器中值为elem的元素。

3.7.2.5 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的返回值指定set排序规则:

//插入操作返回值

void test01(){

set<int> s;

pair<set<int>::iterator,bool> ret = s.insert(10);

if (ret.second){

cout << "插入成功:" << *ret.first << endl;

}

else{

cout << "插入失败:" << *ret.first << endl;

}

ret = s.insert(10);

if(ret.second){

cout << "插入成功:" << *ret.first << endl;

}

else{

cout << "插入失败:" << *ret.first << endl;

}

struct MyCompare02{

bool operator()(int v1,int v2){

return v1 > v2;

}

};

//set从大到小

void test02(){

srand((unsigned int)time(NULL));

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

set<int, MyCompare02> s;

for (int i = 0; i < 10;i++){

s.insert(rand() % 100);

}

for (set<int, MyCompare02>::iterator it = s.begin(); it != s.end(); it ++){

cout << *it << " ";

}

cout << endl;

}

//set容器中存放对象

class Person{

public:

Person(string name,int age){

this->mName = name;

this->mAge = age;

}

public:

string mName;

int mAge;

};

struct MyCompare03{

bool operator()(const Person& p1,const Person& p2){

return p1.mAge > p2.mAge;

}

};

void test03(){

set<Person, MyCompare03> s;

Person p1("aaa", 20);

Person p2("bbb", 30);

Person p3("ccc", 40);

Person p4("ddd", 50);

s.insert(p1);

s.insert(p2);

s.insert(p3);

s.insert(p4);

for (set<Person, MyCompare03>::iterator it = s.begin(); it != s.end(); it++){

cout << "Name:" << it->mName << " Age:" << it->mAge << endl;

}

3.7.3 对组(pair)

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

类模板：template <class T1, class T2> struct pair.

如何创建对组?

//第一种方法创建一个对组

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;

3.8 map/multimap容器

3.8.1 map/multimap基本概念

Map的特性是，所有元素都会根据元素的键值自动排序。Map所有的元素都是pair,同时拥有实值和键值，pair的第一元素被视为键值，第二元素被视为实值，map不允许两个元素有相同的键值。

我们可以通过map的迭代器改变map的键值吗？答案是不行，因为map的键值关系到map元素的排列规则，任意改变map键值将会严重破坏map组织。如果想要修改元素的实值，那么是可以的。

Map和list拥有相同的某些性质，当对它的容器元素进行新增操作或者删除操作时，操作之前的所有迭代器，在操作完成之后依然有效，当然被删除的那个元素的迭代器必然是个例外。

Multimap和map的操作类似，唯一区别multimap键值可重复。

Map和multimap都是以红黑树为底层实现机制。

3.8.2 map/multimap常用API

3.8.2.1 map构造函数

map<T1, T2> mapTT;//map默认构造函数:

map(const map &mp);//拷贝构造函数

3.8.2.2 map赋值操作

map& operator=(const map &mp);//重载等号操作符

swap(mp);//交换两个集合容器

3.8.2.3 map大小操作

size();//返回容器中元素的数目

empty();//判断容器是否为空

3.8.2.4 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] = "小王";

3.8.2.5 map删除操作

clear();//删除所有元素

erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。

erase(beg,end);//删除区间[beg,end)的所有元素，返回下一个元素的迭代器。

erase(keyElem);//删除容器中key为keyElem的对组。

3.8.2.6 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相等的上下限的两个迭代器。

3.8.3 multimap案例

//公司今天招聘了5个员工，5名员工进入公司之后，需要指派员工在那个部门工作

//人员信息有: 姓名年龄电话工资等组成

//通过Multimap进行信息的插入保存显示

//分部门显示员工信息显示全部员工信息

#define _CRT_SECURE_NO_WARNINGS

#include<iostream>

#include<map>

#include<string>

#include<vector>

using namespace std;

//multimap 案例

//公司今天招聘了 5 个员工，5 名员工进入公司之后，需要指派员工在那个部门工作

//人员信息有: 姓名年龄电话工资等组成

//通过 Multimap 进行信息的插入保存显示

//分部门显示员工信息显示全部员工信息

#define SALE_DEPATMENT 1 //销售部门

#define DEVELOP_DEPATMENT 2 //研发部门

#define FINACIAL_DEPATMENT 3 //财务部门

#define ALL_DEPATMENT 4 //所有部门

//员工类

class person{

public:

string name; //员工姓名

int age; //员工年龄

double salary; //员工工资

string tele; //员工电话

};

//创建5个员工

void CreatePerson(vector<person>& vlist){

string seed = "ABCDE";

for (int i = 0; i < 5; i++){

person p;

p.name = "员工";

p.name += seed[i];

p.age = rand() % 30 + 20;

p.salary = rand() % 20000 + 10000;

p.tele = "010-8888888";

vlist.push_back(p);

}

//5名员工分配到不同的部门

void PersonByGroup(vector<person>& vlist, multimap<int, person>& plist){

int operate = -1; //用户的操作

for (vector<person>::iterator it = vlist.begin(); it != vlist.end(); it++){

cout << "当前员工信息:" << endl;

cout << "姓名：" << it->name << " 年龄:" << it->age << " 工资:" << it->salary << " 电话：" << it->tele << endl;

cout << "请对该员工进行部门分配(1 销售部门, 2 研发部门, 3 财务部门):" << endl;

scanf("%d", &operate);

while (true){

if (operate == SALE_DEPATMENT){ //将该员工加入到销售部门

plist.insert(make_pair(SALE_DEPATMENT, *it));

break;

}

else if (operate == DEVELOP_DEPATMENT){

plist.insert(make_pair(DEVELOP_DEPATMENT, *it));

break;

}

else if (operate == FINACIAL_DEPATMENT){

plist.insert(make_pair(FINACIAL_DEPATMENT, *it));

break;

}

else{

cout << "您的输入有误，请重新输入(1 销售部门, 2 研发部门, 3 财务部门):" << endl;

scanf("%d", &operate);

}

cout << "员工部门分配完毕!" << endl;

cout << "***********************************************************" << endl;

}

//打印员工信息

void printList(multimap<int, person>& plist, int myoperate){

if (myoperate == ALL_DEPATMENT){

for (multimap<int, person>::iterator it = plist.begin(); it != plist.end(); it++){

cout << "姓名：" << it->second.name << " 年龄:" << it->second.age << " 工资:" << it->second.salary << " 电话：" << it->second.tele << endl;

}

return;

}

multimap<int, person>::iterator it = plist.find(myoperate);

int depatCount = plist.count(myoperate);

int num = 0;

if (it != plist.end()){

while (it != plist.end() && num < depatCount){

cout << "姓名：" << it->second.name << " 年龄:" << it->second.age << " 工资:" << it->second.salary << " 电话：" << it->second.tele << endl;

it++;

num++;

}

//根据用户操作显示不同部门的人员列表

void ShowPersonList(multimap<int, person>& plist, int myoperate){

switch (myoperate)

{

case SALE_DEPATMENT:

printList(plist, SALE_DEPATMENT);

break;

case DEVELOP_DEPATMENT:

printList(plist, DEVELOP_DEPATMENT);

break;

case FINACIAL_DEPATMENT:

printList(plist, FINACIAL_DEPATMENT);

break;

case ALL_DEPATMENT:

printList(plist, ALL_DEPATMENT);

break;

}

//用户操作菜单

void PersonMenue(multimap<int, person>& plist){

int flag = -1;

int isexit = 0;

while (true){

cout << "请输入您的操作((1 销售部门, 2 研发部门, 3 财务部门, 4 所有部门, 0退出)：" << endl;

scanf("%d", &flag);

switch (flag)

{

case SALE_DEPATMENT:

ShowPersonList(plist, SALE_DEPATMENT);

break;

case DEVELOP_DEPATMENT:

ShowPersonList(plist, DEVELOP_DEPATMENT);

break;

case FINACIAL_DEPATMENT:

ShowPersonList(plist, FINACIAL_DEPATMENT);

break;

case ALL_DEPATMENT:

ShowPersonList(plist, ALL_DEPATMENT);

break;

case 0:

isexit = 1;

break;

default:

cout << "您的输入有误，请重新输入!" << endl;

break;

}

if (isexit == 1){

break;

}

int main(){

vector<person> vlist; //创建的5个员工未分组

multimap<int, person> plist; //保存分组后员工信息

//创建5个员工

CreatePerson(vlist);

//5名员工分配到不同的部门

PersonByGroup(vlist, plist);

//根据用户输入显示不同部门员工信息列表或者显示全部员工的信息列表

PersonMenue(plist);

system("pause");

return EXIT_SUCCESS;

}

3.9 STL容器使用时机

	vector	deque	list	set	multiset	map	multimap
典型内存结构	单端数组	双端数组	双向链表	二叉树	二叉树	二叉树	二叉树
可随机存取	是	是	否	否	否	对key而言：不是	否
元素搜寻速度	慢	慢	非常慢	快	快	对key而言：快	对key而言：快
元素安插移除	尾端	头尾两端	任何位置	-	-	-	-

u vector的使用场景：比如软件历史操作记录的存储，我们经常要查看历史记录，比如上一次的记录，上上次的记录，但却不会去删除记录，因为记录是事实的描述。

u deque的使用场景：比如排队购票系统，对排队者的存储可以采用deque，支持头端的快速移除，尾端的快速添加。如果采用vector，则头端移除时，会移动大量的数据，速度慢。

vector与deque的比较：

一：vector.at()比deque.at()效率高，比如vector.at(0)是固定的，deque的开始位置却是不固定的。

二：如果有大量释放操作的话，vector花的时间更少，这跟二者的内部实现有关。

三：deque支持头部的快速插入与快速移除，这是deque的优点。

u list的使用场景：比如公交车乘客的存储，随时可能有乘客下车，支持频繁的不确实位置元素的移除插入。

u set的使用场景：比如对手机游戏的个人得分记录的存储，存储要求从高分到低分的顺序排列。

u map的使用场景：比如按ID号存储十万个用户，想要快速要通过ID查找对应的用户。二叉树的查找效率，这时就体现出来了。如果是vector容器，最坏的情况下可能要遍历完整个容器才能找到该用户。

4. 常用算法

4.1 函数对象

重载函数调用操作符的类，其对象常称为函数对象（function object），即它们是行为类似函数的对象，也叫仿函数(functor),其实就是重载“()”操作符，使得类对象可以像函数那样调用。

注意:

1.函数对象(仿函数)是一个类，不是一个函数。

2.函数对象(仿函数)重载了”() ”操作符使得它可以像函数一样调用。

分类:假定某个类有一个重载的operator()，而且重载的operator()要求获取一个参数，我们就将这个类称为“一元仿函数”（unary functor）；相反，如果重载的operator()要求获取两个参数，就将这个类称为“二元仿函数”（binary functor）。

函数对象的作用主要是什么？STL提供的算法往往都有两个版本，其中一个版本表现出最常用的某种运算，另一版本则允许用户通过template参数的形式来指定所要采取的策略。

//函数对象是重载了函数调用符号的类

class MyPrint

{

public:

MyPrint()

{

m_Num = 0;

}

int m_Num;

public:

void operator() (int num)

{

cout << num << endl;

m_Num++;

}

};

//函数对象

//重载了()操作符的类实例化的对象，可以像普通函数那样调用,可以有参数，可以有返回值

void test01()

{

MyPrint myPrint;

myPrint(20);

}

// 函数对象超出了普通函数的概念，可以保存函数的调用状态

void test02()

{

MyPrint myPrint;

myPrint(20);

cout << myPrint.m_Num << endl;

}

void doBusiness(MyPrint print,int num)

{

print(num);

}

//函数对象作为参数

void test03()

{

//参数1：匿名函数对象

doBusiness(MyPrint(),30);

}

总结：

1、函数对象通常不定义构造函数和析构函数，所以在构造和析构时不会发生任何问题，避免了函数调用的运行时问题。

2、函数对象超出普通函数的概念，函数对象可以有自己的状态

3、函数对象可内联编译，性能好。用函数指针几乎不可能

4、模版函数对象使函数对象具有通用性，这也是它的优势之一

4.2 谓词

谓词是指普通函数或重载的operator()返回值是bool类型的函数对象(仿函数)。如果operator接受一个参数，那么叫做一元谓词,如果接受两个参数，那么叫做二元谓词，谓词可作为一个判断式。

class GreaterThenFive

{

public:

bool operator()(int num)

{

return num > 5;

}

};

//一元谓词

void test01()

{

vector<int> v;

for (int i = 0; i < 10;i ++)

{

v.push_back(i);

}

vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterThenFive());

if (it == v.end())

{

cout << "没有找到" << endl;

}

else

{

cout << "找到了: " << *it << endl;

}

//二元谓词

class MyCompare

{

public:

bool operator()(int num1, int num2)

{

return num1 > num2;

}

};

void test02()

{

vector<int> v;

v.push_back(10);

v.push_back(40);

v.push_back(20);

v.push_back(90);

v.push_back(60);

//默认从小到大

sort(v.begin(), v.end());

for (vector<int>::iterator it = v.begin(); it != v.end();it++)

{

cout << *it << " ";

}

cout << endl;

cout << "----------------------------" << endl;

//使用函数对象改变算法策略，排序从大到小

sort(v.begin(), v.end(),MyCompare());

for (vector<int>::iterator it = v.begin(); it != v.end(); it++)

{

cout << *it << " ";

}

cout << endl;

}

4.3 内建函数对象

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

n 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>//取反仿函数

n 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>//小于等于

n 逻辑运算类运算函数,not为一元运算，其余为二元运算。

template<class T> bool logical_and<T>//逻辑与

template<class T> bool logical_or<T>//逻辑或

template<class T> bool logical_not<T>//逻辑非

内建函数对象举例:

//取反仿函数

void test01()

{

negate<int> n;

cout << n(50) << endl;

}

//加法仿函数

void test02()

{

plus<int> p;

cout << p(10, 20) << endl;

}

//大于仿函数

void test03()

{

vector<int> v;

srand((unsigned int)time(NULL));

for (int i = 0; i < 10; i++){

v.push_back(rand() % 100);

}

for (vector<int>::iterator it = v.begin(); it != v.end(); it++){

cout << *it << " ";

}

cout << endl;

sort(v.begin(), v.end(), greater<int>());

for (vector<int>::iterator it = v.begin(); it != v.end(); it++){

cout << *it << " ";

}

cout << endl;

}

3.1.4 函数对象适配器

//函数适配器bind1st bind2nd

//我们直接给函数对象绑定参数编译阶段就会报错

//for_each(v.begin(), v.end(), bind2nd(myprint(),100));

//如果我们想使用绑定适配器,需要我们自己的函数对象继承binary_function 或者 unary_function

//根据我们函数对象是一元函数对象还是二元函数对象

class MyPrint :public binary_function<int,int,void>

void operator()(int v1,int v2) const

public:

cout << "v1 = : " << v1 << " v2 = :" <<v2 << " v1+v2 = :" << (v1 + v2) << endl;

for (int i = 0; i < 10; i++)

cout << "请输入起始值：" << endl;

int x;

cin >> x;

for_each(v.begin(), v.end(), bind1st(MyPrint(), x));

//for_each(v.begin(), v.end(), bind2nd( MyPrint(),x ));

//bind1st ：将参数绑定为函数对象的第一个参数

//总结： bind1st和bind2nd区别?

//bind2nd ：将参数绑定为函数对象的第二个参数

//bind1st bind2nd将二元函数对象转为一元函数对象

class GreaterThenFive:public unary_function<int,bool>

bool operator ()(int v) const

public:

for (int i = 0; i < 10;i++)

// vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterThenFive()); //返回第一个大于5的迭代器

// vector<int>::iterator it = find_if(v.begin(), v.end(), not1(GreaterThenFive())); //返回第一个小于5迭代器

//自定义输入

vector<int>::iterator it = find_if(v.begin(), v.end(), not1 ( bind2nd(greater<int>(),5)));

if (it == v.end())

cout << "没找到" << endl;

else

cout << "找到" << *it << endl;

sort(v.begin(), v.end(), not2(less<int>()));

//排序二元函数对象

for_each(v.begin(), v.end(), [](int val){cout << val << " "; });

void MyPrint03(int v,int v2)

//not1 对一元函数对象取反

//not2 对二元函数对象取反

for (int i = 0; i < 10; i++)

cout << v + v2<< " ";

// ptr_fun( )把一个普通的函数指针适配成函数对象

for_each(v.begin(), v.end(), bind2nd( ptr_fun( MyPrint03 ), 100));

Person(string name, int age)

cout << "成员函数:" << "Name:" << m_Name << " Age:" << m_Age << endl;

void MyPrint04(Person &p)

cout << "姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;

Person p1("aaa", 10);

Person p2("bbb", 20);

Person p3("ccc", 30);

Person p4("ddd", 40);

//for_each(v.begin(), v.end(), MyPrint04);

//利用 mem_fun_ref 将Person内部成员函数适配

for_each(v.begin(), v.end(), mem_fun_ref(&Person::ShowPerson));

// for_each(v.begin(), v.end(), mem_fun_ref(&Person::Plus100));

// for_each(v.begin(), v.end(), mem_fun_ref(&Person::ShowPerson));

for_each(v1.begin(), v1.end(), mem_fun(&Person::ShowPerson));

void test05(){

vector<Person*> v1;

//创建数据

Person p1("aaa", 10);

Person p2("bbb", 20);

Person p3("ccc", 30);

Person p4("ddd", 40);