STL

为了建立数据结构和算法的一套标准，并且降低他们之间的耦合关系，以提升各自的独立性、弹性、交互操作性(相互合作性,interoperability),诞生了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 tempalte

*** STL六大组件的交互关系，容器通过空间配置器取得数据存储空间，算法通过迭代器存储容器中的内容，仿函数可以协助算法完成不同的策略的变化，适配器可以修饰仿函数***

STL的优点

• STL 是 C++的一部分，因此不用额外安装什么，它被内建在你的编译器之内。
• STL 的一个重要特性是将数据和操作分离。数据由容器类别加以管理，操作则由可定制的算法定义。迭代器在两者之间充当“粘合剂”,以使算法可以和容器交互运作
• 程序员可以不用思考 STL 具体的实现过程，只要能够熟练使用 STL 就 OK 了。这样他们就可以把精力放在程序开发的别的方面。
• STL 具有高可重用性，高性能，高移植性，跨平台的优点。
  • 高可重用性：STL 中几乎所有的代码都采用了模板类和模版函数的方式实现，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。关于模板的知
    识，已经给大家介绍了。
  • 高性能：如 map 可以高效地从十万条记录里面查找出指定的记录，因为 map 是采用红黑树的变体实现的。
  • 高移植性：如在项目 A 上用 STL 编写的模块，可以直接移植到项目 B 上。

迭代器

迭代器(iterator)是一种抽象的设计概念，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式

普通迭代器 iterator
逆序迭代器 reverse_iterator
只读迭代器 const_iterator

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void test()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);

    vector<int>::iterator itBegin = v.begin();
    vector<int>::iterator itEnd = v.end();
    while (itBegin != itEnd)
    {
        cout << *itBegin << endl;
        itBegin++;
    }
   
}

void prittest(int x)
{
    cout << x << endl;
}

void test01()
{
    vector<int> v;

    for(int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    for_each(v.begin(), v.end(),prittest);
}

void test02()
{
    vector<vector<int> > v;

    vector<int> v1;
    vector<int> v2;
    vector<int> v3;

    for(int i = 0; i < 5; i++)
    {
        v1.push_back(i);
        v2.push_back(i+10);
        v3.push_back(i+20);
    }

    v.push_back(v1);
    v.push_back(v2);
    v.push_back(v3);

    for(vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
    {
        for(vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
        {
            cout << (*vit) << "    ";
        }

        cout << endl;
    }
}

int main()
{
    //test();
    //test01();
    test02();

    return 0;
} 

容器

容器分为序列式容器和关联式容器

• 序列式容器强调值的排序，序列式容器中的每个元素均有固定的位置，除非用删除或插入的操作改变这个位置。Vector容器、Deque容器、List容器等。
• 关联式容器是非线性的树结构，更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系，也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。关联式容器另一个显著特点是：在值中选择一个值作为关键字key，这个关键字对值起到索引的作用，方便查找。Set / multiset 容器 Map / multimap 容器

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

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（s 的长度可以和 n 不同）

string比较操作

/*
compare函数在>时返回 1，<时返回 -1，==时返回 0。
比较区分大小写，比较时参考字典顺序，排越前面的越小。
大写的A比小写的a小。
*/
int compare(const string &s) const;//与字符串s比较
int compare(const char *s) const;//与字符串s比较
3.1.2.7 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字符串转换

const char*到string具有隐式类型转换
string对象到C_string不存在隐式类型转换

//string 转 char*
string str = "itcast";
const char* cstr = str.c_str();
//char* 转 string 
char* s = "itcast";
string str(s);

vector容器

• vector模拟动态数组
• vector的元素可以是任意类型T，但必须具备赋值和拷贝能力（具有public拷贝构造函数和重载的赋值操作符）
• vector支持随机存取
• vector的大小（size）和容量（capacity）通常是不同的，size返回实际元素个数，capacity返回vector能容纳的元素最大数量。如果插入元素时，元素个数超过capacity，需要重新配置内部存储器。
• Vector所采用的数据结构非常简单，线性连续空间，它以两个迭代器_Myfirst和_Mylast分别指向配置得来的连续空间中目前已被使用的范围，并以迭代器_Myend 指向整块连续内存空间的尾端。

vector构造函数

vector<T> v; //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end());//将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem);//构造函数将n个elem拷贝给本身。
vector(const vector &vec);//拷贝构造函数。

//例子 使用第二个构造函数 我们可以...
int arr[] = {2,3,4,1,9};
vector<int> v1(arr, arr + sizeof(arr) / sizeof(int)); 

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，收缩内存空间
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
using namespace std;

int main(){

	vector<int> v;
	for (int i = 0; i < 100000;i ++){
		v.push_back(i);
	}

	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;
}


//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;
}

deque容器

Vector容器是单向开口的连续内存空间，deque则是一种双向开口的连续线性空间。所谓的双向开口，意思是可以在头尾两端分别做元素的插入和删除操作

• deque模拟动态数组
• deque的元素可以是任意类型T，但必须具备赋值和拷贝能力（具有public拷贝构造函数和重载的赋值操作符）
• deque支持随机存取
• deque支持在头部和尾部存储数据
• deque不支持capacity和reserve操作

deque容器的实现

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位置的数据，返回下一个数据的位置。

stack容器

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

• 有元素推入栈的操作称为:push,将元素推出stack的操作称为pop.
• Stack所有元素的进出都必须符合”先进后出”的条件，只有stack顶端的元素，才有机会被外界取用。Stack不提供遍历功能，也不提供迭代器。

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是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口，queue容器允许从一端新增元素，从另一端移除元素。
Queue所有元素的进出都必须符合”先进先出”的条件，只有queue的顶端元素，才有机会被外界取用。Queue不提供遍历功能，也不提供迭代器。

queue构造函数

queue<T> queT;//queue采用模板类实现，queue对象的默认构造形式：
queue(const queue &que);//拷贝构造函数

queue存取、插入和删除操作

push(elem);//往队尾添加元素
pop();//从队头移除第一个元素
back();//返回最后一个元素
front();//返回第一个元素

queue赋值操作

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

queue大小操作

empty();//判断队列是否为空
size();//返回队列的大小

list容器

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
相较于vector的连续线性空间，list就显得负责许多，它的好处是每次插入或者删除一个元素，就是配置或者释放一个元素的空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素的移除，list永远是常数时间。

• List和vector是两个最常被使用的容器。
• List容器是一个循环双向链表。
• 采用动态存储分配，不会造成内存浪费和溢出
• 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
• 链表灵活，但是空间和时间额外耗费较大
• list是一个双向链表，迭代器必须能够具备前移、后移的能力，所以list容器提供的是Bidirectional Iterators. List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效。这在vector是不成立的，因为vector的插入操作可能造成记忆体重新配置，导致原有的迭代器全部失效，甚至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排序，所有不支持随机访问的迭代器不可以用系统提供的算法，如果不支持用系统提供的算法,那么这个类内部会提供

set/multiset容器

set 的特性是：

• 所有元素都会根据元素的键值自动被排序。
• set 的元素不像 map 那样可以同时拥有实值和键值，set 的元素即是键值又是实值。
• set 不允许两个元素有相同的键值。
• set 的 iterator 是一种 const_iterator ，不可以通过迭代器改变 set 的值，会破坏set 的组织
• 当对容器中的元素进行插入操作或者删除操作的时候，操作之前所有的迭代器，在操作完成之后依然有效，被删除的那个元素的迭代器必然是一个例外。

multiset容器

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

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的返回值 & 指定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;
	}

}

对组(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;

map/multimap容器

map 的特性是

• 所有元素都会根据元素的键值自动排序。
• map 所有的元素都是 pair,同时拥有实值和键值，pair 的第一元素被视为键值，第二元素被视为实值，
• map 不允许两个元素有相同的键值。
• 任意改变map键值将会严重破坏map组织。如果想要修改元素的实值，那么是可以的。
• 当对它的容器元素进行新增操作或者删除操作时，操作之前的所有迭代器，在操作完成之后依然有效，当然被删除的那个元素的迭代器必然是个例外
• 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相等的上下限的两个迭代器。

STL容器的比较

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

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

  • vecto r与 deque 的比较：
    1. vector.at() 比 deque.at() 效率高，比如 vector.at(0) 是固定的，deque 的开始位置 却是不固定的。
  2. 如果有大量释放操作的话，vector 花的时间更少，这跟二者的内部实现有关。
  3. deque 支持头部的快速插入与快速移除，这是deque的优点。

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

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

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

函数对象

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

• 函数对象(仿函数)是一个类，不是一个函数
• 函数对象(仿函数)重载了”() ”操作符使得它可以像函数一样调用
• 可以内部记录状态数据
• 作为类型，与模板一起使用

class MyPrint{
public:
    MyPrint()
    {
        count = 0;
    }
    void operator()(int i)
    {
        cout << i << endl;
        count++;
    }

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

//函数对象可以直接做函数参数
void doPrint(MyPrint print, int num)
{
    print(num);
}

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

    cout << myPrint.count << endl;

    doPrint(myPrint,30);
    doPrint(MyPrint(), 40);  //匿名对象
}

谓词

谓词是指普通函数或重载的operator()返回值是bool类型的函数对象(仿函数)。

• 如果operator接受一个参数，那么叫做一元谓词,如果接受两个参数，那么叫做二元谓词
• 谓词可作为一个判断式
• 作为函数参数，必须是一个对象

内建函数对象

头文件：#include <functional>
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>//取反仿函数

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

template<class T> bool logical_and<T>//逻辑与
template<class T> bool logical_or<T>//逻辑或
template<class T> bool logical_not<T>//逻辑非 

void test02()
{
    plus<int> p;
    cout << p(20,30) << endl;
}

适配器

函数适配器

• bind2nd
• 继承 : public binary_functional<函数参数1，函数参数2， 返回值>
• const 修饰 operator()

class MyPrint1 : public binary_function<int,int,void>
{
public:
    void operator()(int v,int start) const
    {
        cout << "v = " << v << "  start = " << start << "  v+strat = " << v + start << endl;
    }
};

void test03()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    cout << "请输入起始值" << endl;
    int num;
    cin >> num;

    for_each(v.begin(), v.end(),bind2nd(MyPrint1(), num));
    /*
    请输入起始值
	20
	v = 0  start = 20  v+strat = 20
	v = 1  start = 20  v+strat = 21
	v = 2  start = 20  v+strat = 22
	v = 3  start = 20  v+strat = 23
	v = 4  start = 20  v+strat = 24
	v = 5  start = 20  v+strat = 25
	v = 6  start = 20  v+strat = 26
	v = 7  start = 20  v+strat = 27
	v = 8  start = 20  v+strat = 28
	v = 9  start = 20  v+strat = 29
    */
    //for_each(v.begin(), v.end(),bind1st(MyPrint1(), num));
    /*绑定1和2不同，一般绑定2
    请输入起始值
	20
	v = 20  start = 0  v+strat = 20
	v = 20  start = 1  v+strat = 21
	v = 20  start = 2  v+strat = 22
	v = 20  start = 3  v+strat = 23
	v = 20  start = 4  v+strat = 24
	v = 20  start = 5  v+strat = 25
	v = 20  start = 6  v+strat = 26
	v = 20  start = 7  v+strat = 27
	v = 20  start = 8  v+strat = 28
	v = 20  start = 9  v+strat = 29
    */
}

取反适配器

函数指针适配器

成员函数适配器

//取反适配器
void test04()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

    vector<int>::iterator pos = find_if(v.begin(), v.end(), bind2nd(greater<int>(),5)); //必须为一个对象

    if(pos != v.end())
    {
        cout << "找到了比5大的数，为 " << *pos << endl;
    }
    else
    {
        cout << "没找到" << endl;
    }


    pos = find_if(v.begin(), v.end(), not1(bind2nd(greater<int>(),5))); //取反

    if(pos != v.end())
    {
        cout << "找到了比5小的数，为 " << *pos << endl;
    }
    else
    {
        cout << "没找到" << endl;
    }
    
}

void MyPrint2(int v, int v2)
{
    cout << v + v2 << "  ";
}

//函数指针适配器
void test05()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }

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

//成员函数适配器
class Person
{
public:
    Person(string name, int age)
    {
        m_name = name;
        m_age = age;
    }

    void showPerson() const
    {
        cout << "姓名：  " << m_name << "年龄：  " << m_age << endl;
    }

    void plus()
    {
        this->m_age = this->m_age + 1;
    }

    string m_name;
    int m_age;
};

void test06()
{
    vector<Person> v;

    Person p1("aaa", 10);
    Person p2("bbb", 20);
    Person p3("ccc", 30);
    Person p4("ddd", 40);
    Person p5("eee", 50);

    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    v.push_back(p5);
	//注意用的是&
    for_each(v.begin(), v.end(),mem_fun_ref(&Person::showPerson));

    for_each(v.begin(), v.end(),mem_fun_ref(&Person::plus));
    for_each(v.begin(), v.end(),mem_fun_ref(&Person::showPerson));
}

void test07()
{
    vector<Person*> v;

    Person p1("aaa", 10);
    Person p2("bbb", 20);
    Person p3("ccc", 30);
    Person p4("ddd", 40);
    Person p5("eee", 50);

    v.push_back(&p1);
    v.push_back(&p2);
    v.push_back(&p3);
    v.push_back(&p4);
    v.push_back(&p5);

    for_each(v.begin(), v.end(),mem_fun(&Person::showPerson));

    for_each(v.begin(), v.end(),mem_fun(&Person::plus));
    for_each(v.begin(), v.end(),mem_fun(&Person::showPerson));
}

算法

算法分为质变算法和非质变算法。

• 质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等
• 非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等

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

遍历算法

for_each

for_each(iterator begin, iterator end, _callback);

for_each(v.begin(), v.end(),MyPrint; //函数名
for_each(v.begin(), v.end(),MyPrint()); //仿函数，对象
for_each(v.begin(), v.end(),bind2nd(MyPrint1(), num)); //适配器

transform 算法

将指定容器区间元素搬运到另一容器中

//transform(iterator beg1, iterator end1, iterator beg2, _callbakc)

struct transformTest01{
	int operator()(int val){
		return val + 100;
	}
};
struct print01{
	void operator()(int val){
		cout << val << " ";
	}
};
void test()
{
	vector<int> vSource;
	
	for (int i = 0; i < 10;i ++)
	{
		vSource.push_back(i + 1);
	}

	//目标容器
	vector<int> vTarget;
	
	//给vTarget开辟空间
	vTarget.resize(vSource.size());
	
	//将vSource中的元素搬运到vTarget
	vector<int>::iterator it = transform(vSource.begin(), vSource.end(), vTarget.begin(), transformTest01());
	
	//打印
	for_each(vTarget.begin(), vTarget.end(), print01()); cout << endl;
}

//将容器1和容器2中的元素相加放入到第三个容器中
struct transformTest02
{
	int operator()(int v1,int v2){
		return v1 + v2;
	}
};
void test02()
{
	vector<int> vSource1;
	vector<int> vSource2;
	
	for (int i = 0; i < 10; i++){
		vSource1.push_back(i + 1);	
	}

	//目标容器
	vector<int> vTarget;
	
	//给vTarget开辟空间
	vTarget.resize(vSource1.size());
	transform(vSource1.begin(), vSource1.end(), vSource2.begin(),vTarget.begin(), transformTest02());
	
	//打印
	for_each(vTarget.begin(), vTarget.end(), print01()); cout << endl;
}

查找算法

find(iterator beg, iterator end, value)

//_callback 回调函数或者谓词(返回bool类型的函数对象)
//bool 查找返回true 否则false
find_if(iterator beg, iterator end, _callback); 

//adjacent_find算法 查找相邻重复元素
//返回相邻元素的第一个位置的迭代器
adjacent_find(iterator beg, iterator end, _callback);

//binary_search算法 二分查找法
//bool 查找返回true 否则false
//在无序序列中不可用
bool binary_search(iterator beg, iterator end, value);


//count算法 统计元素出现次数
// int返回元素个数
count(iterator beg, iterator end, value);
count_if(iterator beg, iterator end, _callback);

排序算法

//merge算法 容器元素合并，并存储到另一容器中
// dest  目标容器开始迭代器
merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)

//sort算法 容器元素排序
//两个容器必须是有序的
// _callback 回调函数或者谓词(返回bool类型的函数对象)
sort(iterator beg, iterator end, _callback)

//random_shuffle算法 对指定范围内的元素随机调整次序
random_shuffle(iterator beg, iterator end)

//reverse算法 反转指定范围的元素
reverse(iterator beg, iterator end)

拷贝和替换算法

//copy算法 将容器内指定范围的元素拷贝到另一容器中
copy(iterator beg, iterator end, iterator dest)
//copy的一个用法，实现for_each的功能
copy(v.begin(), v.end(), ostream_iterator<int>(cout," "));

//replace算法 将容器内指定范围的旧元素修改为新元素
replace(iterator beg, iterator end, oldvalue, newvalue)

//replace_if算法 将容器内指定范围满足条件的元素替换为新元素
replace_if(iterator beg, iterator end, _callback, newvalue)

//swap算法 互换两个容器的元素
swap(container c1, container c2)

算数生成算法

//accumulate算法 计算容器元素累计总和
accumulate(iterator beg, iterator end, value)

//fill算法 向容器中添加元素
fill(iterator beg, iterator end, value)