C++之STL标准模板库

一、概念：STL是一个程序库，包含了高级数据类型(类模板实现)以及操作这些容器类型的通用算法。
二、STL包含的六大部件：容器，迭代器，算法，分配器，适配器，仿函数
2.1 容器：一个可以存放同种数据类型的集合，他是用类模板实现的，里边提供了操作该类性的一些成员函数
2.2 迭代器：主要用来遍历容器中的元素，同时也是连接算法和容器的桥梁
2.3 算法：可以作用于不同的数据类型
三、容器：
2.1 顺序容器：
vector序列容器：底层使用动态数组来实现，意味着元素之间在物理和逻辑上是相邻的，有点事查询容器中元素比较快，缺点是头部插入和中间插入或删除效率比较差，与list相反。

使用vector步骤：
1、引入头文件：  #include<vector>
2、创建对象： vector<对象类型> 对象列表；
3、对象的初始化：空的对象：vector 对象名；  指定个数的对象：vector<int> vt(10);      用另一个对象初始化当前对象：vector<int> a(arr,arr+i);
4、访问vector中的元素：对象名[index];      对象名.at(index);  //会检查数组下标越界
5、获取元素个数：size()
6、插入元素：push_back(元素值)；  insert(pos,插入的元素值)； //pos是一个迭代器对象，begin(),end()
7、修改元素：对象名[index] = new_value;       *迭代器对象 = new_value;
8、删除元素：erase(pos);  删除对应位置的元素
            erase(begin ,end);   //start<=x<end;
            pop_back();  //出栈
9、判空：empty()

list序列容器的特点：底层使用双向循环链表，插入或删除元素的效率比较高，优于vector
1、引入头文件：  #include<list>
2、创建对象： list<对象类型> 对象列表；
3、对象的初始化：空的对象：list 对象名；  指定个数的对象：list<int> a(10);
                用另一个对象初始化当前对象：list<int> a(arr,arr+i);
4、获取元素个数：size() 
5、改变容器大小：resize()
6、插入元素：push_back(末尾元素值)；  push_front(前面插入元素值) 
            insert(插入的元素值)；
7、删除元素：erase(元素值);  //删除对应位置的元
            remove_if(lambda表达式)  [](int n){return n >10}
            pop_back();  //出栈
8、list容器中元素排序:sort();
9、判空：empty()
10、遍历链表元素
     vector<>iterator *it;
     for(it = begin();it != end();it++)
     	cout << *it << endl;

2.2 关联容器：

map容器：由键值对组成，其中关键字不能重复
使用map的函数：
1、引入头文件：  #include<map>
2、创建对象： map<key, value> 对象名称；
3、对象的初始化：map<key, value> 对象名称 = {{}，{}，{}}  //key 和value为模板
4、获取元素个数：size() 
5、修改map中的元素：对象.at()
6、插入元素：对象.insert(pair<key ,value>(键值,数据));
	        对象.insert(map<key ,value>::value_type(键值,数据));
	        对象[键值] = "数据";   //也可以用于修改
7、删除元素：对象.erase(键值);  
8、两个map中的元素交换:对象1.swap(对象2);
9、判空：empty()
10、遍历链表元素
    map<int, string>::iterator it;
    for(it = 对象.begin();it != 对象.end();it++)
	{
		cout << it->first << ":" << it->second << endl;
	}

四、迭代器：主要用于访问容器中的元素，也称泛型指针，但迭代器不是指针，而是类对象，指向容器中的某位置的元素，不同的迭代器必须用于不同的容器。
输出迭代器：允许向序列中写入数据，如输出流迭代器；
前向迭代器：既是输入迭代器，又是输出迭代器，并且可以对序列进行单向的遍历
双向迭代器：与前项迭代器相似，但是在两个方向上都可以对数据遍历
随机访问迭代器：也是双向迭代器，但是能够在序列中的任意两个位置之间进行跳转，如指针， 使用vector的begin()、end()函数得到的迭代器。
借用迭代器遍历容器中的数据：

for(it = container.begin(),it != container.end(),it++)
{
cout << *it;
}

五、算法：常用的数据处理方法，如向容器中插入、删除容器中的元素，查找容器中的元素，对容器中的元素排序，复制容器中的元素等，这些数据处理以函数模板的形式实现的。

包含的头文件 ：
              #include <algorithm>
              #include <functional>
泛型算法分类：(1):不修改序列的操作：
				find()，count()，equal()，mismatch()，search():
       		 (2):修改序列的操作：
 	      		replace()，remove()，reverse()，rotate()，fill():
     		 (3):排序、合并和相关操作：
				sort()，binary_search()，merge()，min()，max():
常用的泛型算法：(1):遍历：for_each()
			   (2):查找:adjacent_find()   查找相邻两个相同元素
                       binary_search()  二分查找,保证查找的数据序列是有序的；
       		   (3)统计：count()/count_if()
       		   (4)删除：remove()/remove_if()/remove_if()
       		   (5)数据搬运：transform()   transform不会为目标容器开辟空间，所以在transform函数搬运时，一定要保证目标容器有空间容纳“搬运来的”数据
       		   (6)排序：sort()   根据第三个参数的函数的名，决定排序的规则
       		   		    random_shuffle()对指定范围内的元素随机调整次序
       		   		    reverse()将制定范围内的元素重新排序
        	   (7)数据合并：merge()   保证查找的数据序列是有序的，目标容器能够有足够的空间容纳合并后的数据
        	   (8)拷贝算法:copy():复制序列
        	              copy_backward():以相反顺序被拷贝

六、谓词(Predicate)：返回值为bool型的普通函数，或者类的成员函数；
一元谓词(UnaryPredicate); 具有一个参数的谓词
二元谓词(BinaryPredicate); 具有二个参数的谓词
七、 函数对象(仿函数)：行为类似于一个函数的类对象，就是重载了（）运算符的类，将这样的类的对象就叫做函数对象，也叫仿函数，这个类的对象可以像函数一样调用

class A
{
bool operator()(int var) {return var>5;}
};            //A a;  a(4)  返回值为false

八、容器适配器 ：stack,queue：

(1)判断容器是否为空：empty();
(2)返回容器的大小： size();
(3)访问下一个元素：top();
(4)插入元素：push();
(5)构造并插入元素：emplace();
(6)删除元素：remove();
(7)交换容器内的元素：swap();