STL

STL 是“Standard Template Library”的缩写，中文译为“标准模板库”。STL 是 C++ 标准库的一部分，不用单独安装。
STL 有很多的容器

C++ STL 设计思路和java的集合设计不同。

Java 中 开发者
使用Java 集合---> 集合框架List,Set,HashMap ...... 等等
只需要面向对象，基本存取，算法
纯粹面向对象封装好

C++ 开发者
使用C++ STL 标准模板库--->STL包+算法包+迭代器
STL包（只有部分函数）Set，List... -----算法包----迭代器
需要自己组装

STL 包全部在命名空间std中

Vector 向量容器 （封装动态大小的数组）

vector 向量

C ++ vector 向量 容器 （内部：封装动态大小数组作为容器，能够存放任意的动态数组【数据结构】）
vector 迭代器，遍历，插入和删除, 源码重载运算符[]

#include <iostream>
#include <vector>
using namespace std;
int main(){
    vector<int> vector1;
    //指定10空间大小
    vector<int> vector2(10);
    //指定10空间大小,每个值0
    vector<int> vector3(10,0);
    vector<int> vector4;
    //vector 迭代器，vector.begin(),vector.end()
    //插入数据
    vector4.insert(vector4.begin(),40);
    vector4.insert(vector4.begin(),60);
    vector4.insert(vector4.begin(),80);
    vector4.insert(vector4.begin(),100);
    vector4.insert(vector4.begin(),200);

    // 第一个
    cout << " 修改前：vector4.front():" << vector4.front() << endl;
    vector4.front() = 99; // 默认修改第一个
    cout << " 修改后：vector4.front():" << vector4.front() << endl;

    // 最后一个
    cout << " 修改前：vector4.back():" << vector4.back() << endl;
    vector4.back() = 777; // 默认修改最后
    cout << " 修改后：vector4.back():" << vector4.back() << endl;

    vector4.erase(vector4.begin()); // 移除第一个元素（内部：通过迭代器的位置 进行移除）  删除

    // 循环打印，默认 从大到小输出
    for (int i = 0; i < vector4.size(); ++i) {
        cout << "item:" << vector4[i] << endl;
    }

    // KT的类型推到  相当于 C++ auto
    /*var a = 10;
    var b = 30.4f;
    var c = "";*/

    // 迭代器 循环遍历
    // auto Kotlin自带类型推到
    // for (vector<int>::iterator iteratorVar = vector4.begin(); iteratorVar != vector4.end(); iteratorVar++) {
    for (auto iteratorVar = vector4.begin(); iteratorVar != vector4.end(); iteratorVar++) {
        // 迭代器 当中指针操作  iteratorVar++
        cout << "迭代器：" << *iteratorVar << endl;
    }

    cout << "" << endl;

    return 0;
}

stack 栈

[] 内部没有重载此运算符
没有迭代器

#include <iostream>
#include <stack>

using namespace std;

int main() {
    stack<int> stackVar;
    // 压栈（注意：stack无法指定那个位置去压栈）
    stackVar.push(30);
    stackVar.push(60);
    stackVar.push(90);
    // [] 角标是不行的，内部没有重载此运算符
    // 他根本就没有迭代器
    // 这种方式是可以的，【会把元素清空】
    while (!stackVar.empty()) {
        int top = stackVar.top();
        cout << "获取栈顶的元素：" << top << endl; // 永远拿 90
        stackVar.pop();// 把栈顶的元素 弹出去  【删除】
    }
    return 0;
}

queue 队列 ,很多地方用到

[] 没有重载，没有迭代器

#include <iostream>
#include <queue>

using namespace std;
int main(){
    queue<int> queueVar;
    queueVar.push(20);
    queueVar.push(40);
    queueVar.push(60);

//    queueVar.front();
//    queueVar.back();
    // 第一个元素是谁 20  FIFO 原则
    cout << " 修改前： queueVar.front():" << queueVar.front() << endl;
    queueVar.front() = 88;
    cout << " 修改后： queueVar.front():" << queueVar.front() << endl;

    // 最后一个
    cout << " 修改前： queueVar.back():" << queueVar.back() << endl;
    queueVar.back() = 88;
    cout << " 修改后： queueVar.back():" << queueVar.back() << endl;


    while (!queueVar.empty()){
        cout << "while1:" << queueVar.front() << endl;

        queueVar.pop(); // 把前面的元素 给消费掉  【删除】
    }

    return 0;
}

优先级队列 priority_queue

隐式代码：vector<int>, less<int>
第二个参数是 vector

#include <iostream>
#include <queue>

using namespace std;
//priority_queue 内部对我们前面的vector 有一定的封装

int main() {
    // 默认从大到小60，50，40...
//    priority_queue<int> priorityQueue;
//隐式代码：vector<int>, less<int>
//    priority_queue<int, vector<int>, less<int>> priorityQueue;
// less<int> return __x < __y;  上一个元素和当前元素 比较，返回ture false  从大到小
    priority_queue<int, vector<int>, greater<int>> priorityQueue;


    priorityQueue.push(10);
    priorityQueue.push(20);
    priorityQueue.push(30);
    priorityQueue.push(40);
    priorityQueue.push(50);
    priorityQueue.push(60);

    cout << priorityQueue.top() << endl; // 60

    // 循环代码
    while (!priorityQueue.empty()) {
        cout << "while1:" << priorityQueue.top() << endl; // 一直是60
        priorityQueue.pop(); // 最前面的元素消费掉
    }
}

list

Java：ArrayList采用Object[]数组， C++的list 内部：采用链表

#include <iostream>
#include <list>

using namespace std;

int main() {
    list<int> listVar;

    // 插入操作
    listVar.push_front(50); // 插入到前面   明确
    listVar.push_back(60); // 插入到后面
    listVar.insert(listVar.begin(), 70); // 插入到前面  灵活
    listVar.insert(listVar.end(), 80); // 插入到后面

    // 修改操作
    listVar.back() = 88;
    listVar.front() = 55;

    // 删除
    listVar.erase(listVar.begin()); // 删除最前面的 55
//    listVar.erase(listVar.end()); // 删除最后面的 88 报错
listVar.remove(listVar.front());
listVar.remove(listVar.back());

    // list 迭代器
    // 不用通过角标去访问，也不能修改   遍历
    for(auto it = listVar.begin(); it != listVar.end(); it++) {
        cout << *it << endl;
    }

    return 0;
}

set 来引出函数谓词。

set（内部：红黑树结构），会对你存入的数据自动进行排序，但是绝对不允许元素相同

#include <iostream>
#include <set>

using namespace std;


int main() {
    set<int, less<int>> setVar; //  __x < __y 从小到大，默认情况下 就是 less

    // 添加参数，不需要用迭代器，也不需要指定位置
    setVar.insert(1);
    setVar.insert(3);
    setVar.insert(2);
    setVar.insert(4);

    // 重复插入，并不会报错  std::pair<iterator, bool>
    pair<set<int, less<int>>::iterator, bool> res = setVar.insert(8);

    // res.first 获取第一个元素 迭代器   当前迭代器   最后一个位置
    // res.second 获取第二个元素 bool
    bool insert_success = res.second;
    if (insert_success) {
        cout << "恭喜你，插入成功" << endl;

        // 插入成功后，我用第一个元素遍历
        for (; res.first != setVar.end(); res.first ++) {
            cout << *res.first << endl;
        }

    } else {
        cout << "哎，插入失败.." << endl;
    }

    // 全部遍历  auto 自动推到
    for (auto it = setVar.begin(); it != setVar.end() ; it ++) {
        cout << *it << endl;
    }

    return 0;
}

C++ 中的谓词

#include <iostream>
#include <set>

using namespace std;

// set（内部：红黑树结构），会对你存入的数据自动进行排序，但是绝对不允许元素相同

class Person {
public:
    string name;
    int id;
    Person(string name, int id) : name(name), id(id) {}
};

// C++ 都是一些常规的 谓词  不能满足功能， 模仿C++源码的谓词 自定义谓词 解决这个问题

// C++缔造者写的这个源码 没有对象比较的功能 【系统源码谓词 做不到对象比较功能】
// bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }

// 我们就自定义这个功能  【自定义谓词 没有达到谓词的标准】
bool doCompareAction(const Person& person1, const Person& person2) {
    return person1.id < person2.id;
};

// 真正的谓词
struct doCompareAction2 {
public:
    bool operator() (const Person& __x, const Person& __y) {
        return __x.id < __y.id;
    }
};

struct doCompareAction3 {
public:
    bool operator() (const Person& __x, const Person& __y) {
        return __x.id > __y.id;
    }
};

int main() {
    // 默认是 less  return 对象1 < 对象2;

    set<Person, doCompareAction2> setVar;

    // set<Person, doCompareAction3> setVar;

    // 构建对象
    Person p1 ("Snake", 1);
    Person p2 ("kevin", 2);
    Person p3 ("Derry", 3);

    // 把构建的对象 插入到 set 容器里面去
    setVar.insert(p1);
    setVar.insert(p2);
    setVar.insert(p3);

    // name string  ---  c_str() ---->   char *
    for (set<Person>::iterator it = setVar.begin(); it != setVar.end() ; it ++) {
        cout << it->name.c_str() << " , " << it->id << endl;
    }

    return 0;
}

map容器

map会对key进行排序，默认 key不能重复
四种插入数据方式：pair，make_pair,map::value_type, 通过下标如mapVal[4] .
迭代器支持

#include <iostream>
#include <map>

using namespace std;

int main() {
    // map 会对key进行排序,key 默认不能重复
    map<int, string> mapVal;
    //添加数据
    mapVal.insert(pair<int, string>(1, "一"));
    mapVal.insert(make_pair(2, "②"));
    mapVal.insert(map<int, string>::value_type(3, "③"));
    mapVal[4] = "四";
    mapVal[4] = "④";



    // 迭代器

    for (map<int, string>::iterator it = mapVal.begin(); it != mapVal.end(); it++) {
        cout << it->first << "," << it->second.c_str() << "\t";
    }
    cout << endl;
    pair<map<int, string>::iterator, bool> result =
            mapVal.insert(map<int, string>::value_type(55, "55"));

    //判断插入成功、失败
    if (result.second) {
        cout << "插入成功" << endl;
    } else {
        cout << "插入失败" << endl;
    }

    // 插入后的数据
    for(result.first = mapVal.begin();result.first != mapVal.end();result.first++){
        cout << result.first->first << " , " << result.first->second <<  endl;

    }
    // 查找，操作
    map<int,string> ::iterator findResult = mapVal.find(3);

    if (findResult != mapVal.end()) {
        cout << "恭喜，找到了" << findResult->first << "," << findResult->second.c_str() << endl;
    } else {
        cout << "不恭喜，没找到了" << endl;
    }    return 0;
}

multimap 容器

1.key可以重复，
2.key重复的数据可以分组,
3.key会排序，
4.value不会排序

#include <iostream>
#include <map>

using namespace std;



int main() {
    // 1.key可以重复， 2.key重复的数据可以分组,  3.key会排序，  4.value不会排序
    multimap<int, string> multimapVar;

    multimapVar.insert(make_pair(10, "十个1"));
    multimapVar.insert(make_pair(10, "十个2"));
    multimapVar.insert(make_pair(10, "十个3"));

    multimapVar.insert(make_pair(30, "三十1"));
    multimapVar.insert(make_pair(30, "三十3"));
    multimapVar.insert(make_pair(30, "三十2"));


    multimapVar.insert(make_pair(20, "二十1"));
    multimapVar.insert(make_pair(20, "二十2"));
    multimapVar.insert(make_pair(20, "二十3"));

    for (auto iteratorVar = multimapVar.begin(); iteratorVar != multimapVar.end() ; iteratorVar ++) {
        cout << iteratorVar->first << "," << iteratorVar->second << endl;
    }
    cout << endl;

    // TODO 核心功能是分组
    int result;
    cout << "请输入你要查询的key，为int类型:" << endl;
    cin >> result;

    multimap<int, string>::iterator iteratorVar = multimapVar.find(result);
    while (iteratorVar != multimapVar.end()) {
        cout << iteratorVar->first << "," << iteratorVar->second << endl;

        // 需要自己做逻辑控制，不然有问题
        iteratorVar++;

        if (iteratorVar->first != result) {
            break;; // 循环结束
        }

        // 严谨性
        if (iteratorVar == multimapVar.end()) {
            break;; // 循环结束
        }
    }

    return 0;
}