STL提供了一组表示容器、迭代器、函数对象和算法的模板。
STL是一种泛型编程。面向对象编程关注的是编程的数据方面，而泛型编程关注的是算法。它们之间的共同点是创建可重用的代码。泛型编程旨在编写独立于数据类型之外的代码。
首先是处理容器的算法，尽可能使用通用的术语来表达算法，使之独立于数据类型和容器类型。

容器，是一个与数组类似的单元，可以存储若干个值，STL容器是同质的，即存储值的类型相同。
算法，是完成特定任务（比如完成排序和查找）的处方。
迭代器，能够用来遍历容器的对象，与能够遍历数组的指针类似，是广义指针。
函数对象，是类似函数的对象，可以是类对象或函数指针（包括函数名，因为函数名被用作指针）。

### STL ###
 *  迭代器
 *  for\_each()函数
 *  random\_shuffle()函数
 *  基于范围的for循环（C++11）
 *  容器
 *   *  容器概念
     *  序列
 *  函数对象

迭代器

迭代器是一个广义指针，它可以是指针，也可以是一个可对其执行类似指针操作（如解引用和递增）的对象。通过指针广义化为迭代器，让STL能够为不同的容器类提供统一的接口。

迭代器使用示例：
使用C++11的自动类型推断

auto pd2 = scores.begin();

清空容器

//方法1
//scores.erase(scores.begin(), scores.end());
//方法2
scores.clear();

push_back()—将元素添加到矢量末尾

scores.push_back(8.8);

erase(it1,it2)—接收两个迭代器参数,删除区间：[it1,it2),删除元素从it1到it2，但不包括it2

scores.erase(scores.begin(), scores.begin() + 2);

insert()—插入元素，接收三个迭代器参数：第一个是新元素的插入位置，第二个和第三个定义被插入区间，该区间通常是另一个容器对象的一部分

scores = {
     1,2,3,4,5,6.6,7.7 };
vector<double> new_v = {
    0.2,0.6,0.7,0.8};
scores.insert(scores.begin() + 3, new_v.begin() + 1, new_v.end());

swap()—交换两个容器的内容

scores.swap(new_v);
//使用拷贝函数生成副本
vector<double> oldlist(scores);
#include <iostream>
#include<string>
#include<vector>
using namespace std;
int main(void) {
    //为vector类的double类型声明一个迭代器：
    vector<double>::iterator pd;
    vector<double> scores = {
    1,2,3,4,5,6.6,7.7};
    //迭代器的行为就像指针
    pd = scores.begin();
    *pd = 23.3;
    ++pd;
    //使用C++11的自动类型推断
    auto pd2 = scores.begin();
    //push_back()---将元素添加到矢量末尾
    scores.push_back(8.8);
    //erase(it1,it2)---接收两个迭代器参数,删除区间：[it1,it2),删除元素从it1到it2，但不包括it2
    scores.erase(scores.begin(), scores.begin() + 2);
    //使用迭代器遍历容器
    cout << "scores:" << endl;
    for (pd = scores.begin(); pd != scores.end(); pd++)
    {
        cout << *pd<<"  " ;
    }
    cout << "" << endl;
    //清空容器
    //方法1
    //scores.erase(scores.begin(), scores.end());
    //方法2
    scores.clear();
    cout << "scores.size(): "<<scores.size() << endl;
    //insert()---插入元素，接收三个迭代器参数：
    //第一个是新元素的插入位置，第二个和第三个定义被插入区间，该区间通常是另一个容器对象的一部分
    scores = {
     1,2,3,4,5,6.6,7.7 };
    vector<double> new_v = {
    0.2,0.6,0.7,0.8};
    scores.insert(scores.begin() + 3, new_v.begin() + 1, new_v.end());
    cout << "insert:" << endl;
    for (pd = scores.begin(); pd != scores.end(); pd++)
    {
        cout << *pd << "  ";
    }
    cout << "" << endl;
    //swap()---交换两个容器的内容
    scores.swap(new_v);
    cout << "After swapping:" << endl;
    for (pd = scores.begin(); pd != scores.end(); pd++)
    {
        cout << *pd << "  ";
    }
    cout << "" << endl;
    //使用拷贝函数生成副本
    vector<double> oldlist(scores);
    for (pd = oldlist.begin(); pd != oldlist.end(); pd++)
    {
        cout << *pd << "  ";
    }
    cout << "" << endl;
    return 0;
}
/*
结果：
scores:
3  4  5  6.6  7.7  8.8
scores.size(): 0
insert:
1  2  3  0.6  0.7  0.8  4  5  6.6  7.7
After swapping:
0.2  0.6  0.7  0.8
0.2  0.6  0.7  0.8
*/

for_each()函数

接收三个参数，前两个是定义容器中区间的迭代器，最后一个是指向函数的指针（更普遍地说，最后一个参数是一个函数对象）。for_each()函数应用于容器区间的各个元素，被指向的函数不能更改容器元素的值。可以用for_each()代替for循环，

void showData(const double & d){
        cout << d << "  ";
}
    for (pd = scores.begin(); pd != scores.end(); pd++)
    {
        showData(*pd);
    }

可以用for_each()代替：

void showData(const double & d){
        cout << d << "  ";
}
for_each(scores.begin(),scores.end(),showData);

random_shuffle()函数

接受两个指定区间的迭代器参数，并随机排列该区间的元素。

random_shuffle(scores.begin(),scores.end());

基于范围的for循环（C++11）

double prices[5] = {
    1,2,3,4,5,6};
for(double x:prices)
    cout<<x<<endl;
for(auto x : scores)
    showData(x);

不同于for_each()，基于范围的for循环可以修改容器的内容，诀窍是指定一个引用参数。

for(auto & x : scores)
    showData(x);

容器

容器概念

容器是存储其他对象的对象。被存储的对象必须是同一类型。
X表示容器类型，T表示存储在容器中的对象类型。
在这里插入图片描述

序列

七种STL容器类型（deque、C++11新增的forward_list、list、queue、priority_queue、stack和vector）都是序列。序列要求其元素按严格的线性顺序排列，数组和链表都是序列，但分支结构不是。
t表示类型为T的值，n表示整数，p、q、i和j表示迭代器。
在这里插入图片描述