STL 常用方法

array

#include <array>
#include <iostream>
using namespace std;

// 固定大小的顺序容器

int main()
{
    // 构造函数
    array<int, 5> a = {1, 2, 3, 4, 5};
    array<int, 3 > b;   // zero-initialized: {？,？,？}
    array<int, 3> c = {10,20};   // initialized as:  {10,20,0}
    array<int, 3> d = c;

    // array数组容器的大小是固定的。可以通过sizeof()、size()、max_size()、empty()等函数进行检测
    cout << a.size() << a.max_size() << endl;
    // 元素可以通过begin/end()、rbegin/rend()、cbegin/cend()、crbegin/crend()等函数进行访问
    for (array<int, 5>::iterator i = a.begin(); i != a.end();i++)
        cout << *i;
    // 可以通过下标[ ]、at()、front()、back()、data()等函数访问array容器内的元素
    cout << endl
         << a.at(3) << a.back() << a.data() << endl; // data():Get pointer to first data, = &a
    // 可以使用fill()、swap()等函数对array容器整体进行操作
    b.swap(c); // <type, n>两个参数都一致才能交换、比较
    c.fill(3);
    // 可以使用>  <  ==等符号对两个array数组容器进行比较
    cout << (c < b) << (c != b) << endl;

    // c++重载了get()函数来访问数组容器中的元素，为了和元组相似，还重载了tuple_size和tuple_element类型
    cout << get<2>(a) << endl;
    get<2>(a) = get<4>(a);
    a[1] = 0;

    return 0;
}

vector

#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
/*
可以发现，对于不带.h的头文件，所有的符号都位于命名空间 std 中，使用时需要声明命名空间 std；
对于带.h的头文件，没有使用任何命名空间，所有符号都位于全局作用域。
*/

bool Comp(const int &a,const int &b)
{
    return a>b;
}

int main()
{
    // 初始化方法
    vector<int> a; // 初始化为空
    vector<int> b{1, 2, 3};
    vector<int> vec={3,2,4,5,4,1,6};
    vector<int> c(vec.begin()+1,vec.end()); // 由两个迭代器指示
    vector<int> d(7); // 7个元素按照默认值初始化
    vector<int> e(vec); 
    vector<int> f(7,3); // 7个元素值为3

    // 插入元素
    vec.push_back(1);  // push_back在尾部插入
    vec.insert(vec.begin() + 1, 9); // 在第一个元素后插入9
    vec.insert(vec.begin(), {1, 2, 3});
    vec.insert(vec.begin(), b.begin(), b.end());
    vec.emplace(vec.begin(), 2); // 只能插入一个元素，效率比insert高
    vec.emplace_back (100); // 尾部插入100
    // 删除元素
    vec.erase(vec.begin()+2); // 删除第3个元素
    vec.erase(vec.begin()+2,vec.begin()+3); // 删除区间[i,j-1];区间从0开始
    vec.pop_back(); // 删除末尾元素

    // 使用迭代器访问元素，也可用下标访问
    vector<int>::iterator it;
    for(it=vec.begin();it!=vec.end();it++)
        cout<<*it<<endl;

    a.clear(); // 清空
    a.empty(); // 检测是否为空
    vec.size();
    vec.at(2); // 等同于下标索引
    vec.front(); // 返回第一个元素的值
    vec.back(); // 返回最后一个元素的值
    // vector的元素可以是全局结构体

    // assign: replacing its current contents, modifying its size accordingly
    a.assign(7, 3); // 7个元素值为3
    a.assign(vec.begin(), vec.begin()+2);
    int k[3]{1, 2, 3};
    a.assign(k, k + 1);

    // 算法：需要头文件 #include<algorithm>
    reverse(a.begin(),a.end()); // 翻转
    sort(vec.begin(),vec.end()-1); // 排序
    // 可以重写排序比较函数按照自定义规则排序
    sort(vec.begin(), vec.end(), Comp);

    // 内存空间只会增长，不会减小
    // capacity()为成员指当前(容器必须分配新存储空间之前)可以存储的元素个数
    a.reserve(10); // 控制容器的预留空间
    // 内存空间会自增长，每当vector容器不得不分配新的存储空间时，会以加倍当前容量的分配策略实现重新分配。
    // 所有内存空间是在vector析构时候才能被系统回收
    // 释放vector内存最简单的方法是vector<int>.swap(nums)，可使空间动态缩小
    vector<int>().swap(vec);  // swap交换容器内容
    vector<int> tmp = vec;  
    vec.swap(tmp);
    // 如果vector中存放的是指针，那么当vector销毁时，这些指针指向的对象不会被销毁
    vec.max_size(); // 返回容器的最大可以存储的元素个数，当容器扩展到这个最大值时就不能再自动增大

    vec.rbegin(); //  反序的第一个元素，也就是正序最后一个元素
    vec.rend(); // 反序的最后一个元素下一个位置，也相当于正序的第一个元素前一个位置
    // r开头的迭代器加减时是反向移动的
    // cbegin,cend为指向constant元素的迭代器，crbegin,crend同理

    // 重新分配容器的元素个数，如果重新分配的元素个数比原来的小将截断序列，如果大于原来的个数，后面的值是c的值，默认为0
    vec.resize(5);
    vec.resize(8, 10); // 多余的值补10

    vec.data(); // 返回一个指向存储元素内存空间的指针

    return 0;
}

list

#include <list>
#include <iostream>
using namespace std;

// list是数据结构中的双向链表，它的内存空间是不连续的，通过指针来进行数据的访问，没有提供[]操作符的重载。

int main()
{
    // 构造函数
    list<int> a;
    list<int> b(5,4);
    list<int> c(b);
    list<int> d = c;
    list<int> e(3);
    list<int> f(b.begin(), b.end());  // 这里b.begin()可以是指向数组的指针

    // 插入
    b.push_back(6); //尾部插入
    b.push_front(9); // 头部插入
    b.insert(b.begin(), 3);
    b.insert(b.begin(), 3, 20); // 插入3个20
    b.insert(b.end(), c.begin(), c.end());
    // splice实现list拼接的功能，将源list的内容部分或全部元素删除，拼插入到目的list
    b.splice(++b.begin(), e);
    e.splice(e.begin(), b, b.begin());
    e.splice(e.begin(), b, b.begin()), b.end();

    b.empty();
    b.resize(5); // 修改容器大小
    b.resize(10, 9);  // 用9初始化新增的元素

    b.front(); // 读取头部元素
    b.back();  // 读取尾部元素

    e.assign(4, 5); // 赋值
    e.assign(b.begin(), b.end());

    b.reverse(); // 逆序

    b.swap(a); // 交换
    swap(a, b);

    // 删除
    c.clear();
    b.pop_back(); // 弹出尾部
    b.pop_front(); // 弹出头部
    b.erase(b.begin());
    b.erase(b.begin(), b.end());
    b.remove(9); // 删除元素9
    // remove_if(func); 删除指定元素
    b.unique(); // 顺序表的去重，只留第一个元素

    // 排序
    b.merge(e, greater<int>()); // 合并两个链表并使之默认升序
    b.sort();

    return 0;
}

stack

#include <iostream>
#include <stack>
#include <deque>
#include <vector>
using namespace std;

int main()
{  
    deque<int> mydeque (3,100);          // deque with 3 elements
    vector<int> myvector (2,200);
    // 构造函数
    // 模板有两个参数，第一个参数是存储对象的类型，第二个参数是底层容器的类型, 默认是 deque<T> 
    // 创建堆栈时，不能在初始化列表中用对象来初始化，但是可以用另一个容器来初始化
    stack<int> a; // 空栈
    stack<int> b (mydeque); // deque的副本
    stack<int,std::vector<int> > c;  // empty stack using vector
    stack<int,std::vector<int> > d(myvector); // 原容器的元素依次入栈

    cout << b.top() << endl; // 读取栈顶
    b.pop();  // 弹出栈顶
    b.push(1); // 对象或副本入栈 通过调用底层容器的有右值引用参数的 push_back() 函数完成
    b.emplace(5); // emplace函数在容器中直接构造元素
    cout << b.size();
    cout << b.empty();
    c.swap(d);

    return 0;
}

queue

#include <iostream>
#include <queue>
#include <list>
#include <vector>
using namespace std;

int main()
{
    // 只能访问第一个和最后一个元素。只能在容器的末尾添加新元素，从头部移除元素。
    // 默认使用deque
    deque<int> mydeck (3,100);   
    list<int> mylist (2,200);    
    // 构造函数
    queue<int> a;
    queue<int> b(a);
    queue<int, list<int>> c;
    queue<int> d(mydeck);
    queue<int, list<int> > e (mylist);

    cout << d.back()  // 最后一个元素
         << d.front() // 第一个元素
         << d.empty()
         << d.size() << endl;
    d.pop(); // 弹出队首元素
    d.push(2); // 入队
    b.swap(a);
    b.emplace(2);

    // priority_queue：元素被赋予优先级，优先队列最高级先出（first in, largest out）
    // 成员基本与queue相同   容器默认是vector
    // 定义：priority_queue<Type, Container, Functional>   Functional 是比较的方式
    priority_queue <int,vector<int>,greater<int> > q; //升序队列，小顶堆
    priority_queue <int,vector<int>,less<int> > p; //降序队列，大顶堆

    return 0;
}

deque

#include <iostream>
#include <deque>
using namespace std;

int main()
{
    // deque双向开口的连续线性空间
    // 允许使用常数项时间对头端进行元素的插入和删除操作
    // 没有容量的概念，是动态的以分段连续空间组合而成，随时可以增加一段新的空间并链接起来
    // 容器也提供的迭代器并不是普通的指针，其复杂度和 vector 不是一个量级

    // 构造函数
    deque<int> a{1,2,3,4};
    deque<int> b(3, 4);
    deque<int> c(b.begin(), b.end()-1);
    deque<int> d(b);

    // 赋值
    a.assign(b.begin(), b.end());
    a.assign(4, 6);
    a = b;
    a.swap(b);

    // 大小
    a.empty();
    a.size();
    a.resize(5); // 以默认值填充
    a.resize(6, 3); // 以指定值填充

    // 插入删除
    a.push_back(4); //在容器尾部添加一个数据
    a.push_front(5); //在容器头部插入一个数据
    a.pop_back(); //删除容器最后一个数据
    a.pop_front(); //删除容器第一个数据
    a.erase(a.begin());
    a.erase(a.begin(), a.begin()+1);
    b.clear();
    a.insert(a.begin(), 3);
    a.insert(a.begin(), 3, 4);
    a.insert(a.begin(), b.begin(), b.end());
    a.emplace(a.begin(), 6);
    a.emplace_front(7);
    a.emplace_back(9);

    // 读取
    a.at(0);
    a.front();
    a.back();

    return 0;
}