C++ 标准模板库STL

模板类 vector

#include <iostream>
#include <vector>

int main() {

    std::vector<int>  v1;
    std::vector<int>  v2(10); // 指定10的空间大小
    std::vector<int>  v3(10, 0); //
    std::vector<int>  v4;

    // 插入
    v4.insert(v4.begin(), 100);
    v4.insert(v4.begin(), 200);
    v4.insert(v4.begin(), 300);
    v4.insert(v4.begin(), 400);

    // 第一个
    std::cout << v4.front() << std::endl;
    v4.front() = 11;
    std::cout << v4.front() << std::endl;

    // 最后一个
    std::cout << v4.back() << std::endl;
    v4.back() = 22;
    std::cout << v4.back() << std::endl;

    // 删除
    v4.erase(v4.begin());

    for (int i = 0; i < v4.size(); ++i) {
        std::cout << v4[i] << std::endl;
    }

    for (std::vector<int>::iterator iteratorVar = v4.begin(); iteratorVar != v4.end(); iteratorVar++) {
        std::cout << *iteratorVar << std::endl;
    }

    return 0;
}

stack

先进后出

#include <iostream>
#include <stack>

int main() {
    std::stack<int> stackVar;

    stackVar.push(11);
    stackVar.push(12);
    stackVar.push(13);

    while (!stackVar.empty()){
        int top = stackVar.top();
        std::cout << top << std::endl;
        stackVar.pop();
    }
    
    return 0;
}

13
12
11

queue

先进先出

#include <iostream>
#include <queue>

int main() {
    std::queue<int> queueVar;

    queueVar.push(10);
    queueVar.push(11);
    queueVar.push(12);

    std::cout << queueVar.front() << std::endl;
    queueVar.front() = 100;
    std::cout << queueVar.front() << std::endl;

    std::cout << queueVar.back() << std::endl;
    queueVar.back() = 300;
    std::cout << queueVar.back() << std::endl;
    
    while (!queueVar.empty()){
        std::cout << queueVar.front() << std::endl;
        queueVar.pop();
    }

    return 0;
}

priority_queue

#include <iostream>
#include <queue>

int main() {
    // 默认做了排序，从大到小
//    std::priority_queue<int> priorityQueue;

    // 隐式代码  默认less从大到下  greater从小到大
//    std::priority_queue<int, std::vector<int>, std::less<int>> priorityQueue;

    // greater 从小到大
    std::priority_queue<int, std::vector<int>, std::greater<int>> priorityQueue;

    priorityQueue.push(10);
    priorityQueue.push(11);
    priorityQueue.push(12);

    while (!priorityQueue.empty()){
        std::cout << priorityQueue.top() << std::endl;
        priorityQueue.pop();
    }

    return 0;
}

list

#include <iostream>
#include <list>

int main() {
    std::list<int> listVar;
    listVar.push_front(10);
    listVar.push_back(100);
    listVar.insert(listVar.begin(), 9);
    listVar.insert(listVar.end(), 101);

    // 修改
    listVar.back() = 200;

    // 删除
    listVar.erase(listVar.begin());

    for (std::list<int>::iterator it = listVar.begin(); it != listVar.end(); it++) {
        std::cout << * it << std::endl;
    }
    
    return 0;
}

set

#include <iostream>
#include <set>

int main() {
    // 默认从小到大 less
    std::set<int, std::less<int>> setVar;
    setVar.insert(10);
    setVar.insert(12);
    setVar.insert(11);
    setVar.insert(13);
    
    for (std::set<int>::iterator it = setVar.begin(); it != setVar.end(); it++) {
        std::cout << * it << std::endl;
    }

    return 0;
}

谓词 - 仿函数

#include <iostream>
#include <set>

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

// 谓词  从小到大
struct doCompareAction1 {
public:
    bool operator() (const  Person& __x, const Person& __y){
        return __x.id < __y.id;
    }
};

// 谓词  从大到小
struct doCompareAction2 {
public:
    bool operator() (const  Person& __x, const Person& __y){
        return __x.id > __y.id;
    }
};

int main() {
    std::set<Person, doCompareAction2> setVar;

    Person p1("zhangSan1", 1001);
    Person p2("zhangSan2", 1002);
    Person p3("zhangSan3", 1003);

    setVar.insert(p1);
    setVar.insert(p2);
    setVar.insert(p3);

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

    return 0;
}

map

key不能重复！

#include <iostream>
#include <map>

int main() {
    std::map<int, std::string> mapVar;

    // 添加数据
    // 方式1
    mapVar.insert(std::pair<int, std::string>(1, "java"));
    // 方式2
    mapVar.insert(std::make_pair(2, "c"));
    // 方式3
    mapVar.insert(std::map<int, std::string>::value_type (3, "c++"));
    // 方式4
    mapVar[4] = "python";
    mapVar[4] = "python2";  // 可以直接修改

    // 判断插入是否成功
    std::pair<std::map<int, std::string>::iterator, bool> result = mapVar.insert(std::map<int, std::string>::value_type (6, "c+++++"));
    if (result.second) {
        std::cout << "insert success" << std::endl;
    } else {
        std::cout << "insert fail" << std::endl;
    }

    // 获取插入后的数据
    for (result.first == mapVar.begin(); result.first != mapVar.end(); result.first++) {
        std::cout << result.first->first << ", " << result.first->second.c_str() << std::endl;
    }

    // 遍历
    for (std::map<int, std::string>::iterator it = mapVar.begin(); it != mapVar.end(); it++) {
        std::cout << it->first << ", " << it->second.c_str() << std::endl;
    }

    // 查找
    std::map<int, std::string>::iterator findRes = mapVar.find(2);
    if (findRes != mapVar.end()) {
        std::cout << "find success. " << findRes->first << ", " << findRes->second.c_str() << std::endl;
    } else {
        std::cout << "find fail. " << std::endl;
    }

    return 0;
}

multimap 分组

key可以重复
key重复的数据可以分组
key会排序
value不会排序

#include <iostream>
#include <map>

int main() {
    std::multimap<int, std::string> multimapVar;

    multimapVar.insert(std::make_pair(1, "hello"));
    multimapVar.insert(std::make_pair(1, "world"));

    multimapVar.insert(std::make_pair(2, "python"));
    multimapVar.insert(std::make_pair(2, "c"));
    multimapVar.insert(std::make_pair(2, "c++"));

    multimapVar.insert(std::make_pair(3, "come"));
    multimapVar.insert(std::make_pair(3, "on"));

    // 遍历
    for (std::map<int, std::string>::iterator it = multimapVar.begin(); it != multimapVar.end(); it++) {
        std::cout << it->first << ", " << it->second.c_str() << std::endl;
    }

    std::map<int, std::string>::iterator findRes = multimapVar.find(2);
    while (findRes != multimapVar.end()){
        std::cout << findRes->first << ", " << findRes->second.c_str() << std::endl;
        findRes++;
        if (findRes->first != 2){
            break;
        }
        if (findRes == multimapVar.end()){
            break;
        }
    }

    return 0;
}

仿函数

#include <iostream>
#include <set>
#include <algorithm>

// 仿函数  一元谓词   (扩展性强)
class showActionObj {
public:
    int count = 0;
    void _count() {
        std::cout << "次数：" << this->count << std::endl;
    }
    void operator()(int content) {
        std::cout << "自定义仿函数" << content << std::endl;
        count++;
    }
};

// 回调函数  但不是仿函数
void showAction(int content) {
    std::cout << "自定义 回调函数" << content << std::endl;
}

int main() {
    std::set<int> setVar;

    setVar.insert(10);
    setVar.insert(20);
    setVar.insert(30);

    // 使用仿函数  可以统计次数
    // std::for_each(setVar.begin(), setVar.end(), showActionObj());
    showActionObj obj;
    // 使用返回的对象
    obj = std::for_each(setVar.begin(), setVar.end(), obj);
    obj._count();


    // 回调函数
    std::for_each(setVar.begin(), setVar.end(), showAction);

    return 0;
}