C++ STL容器汇总

注：为期末考试作复习准备

std::vector<class T>

构造函数：

vector(size_t n, T t = T())

构造容量为n的vector，元素全部填充为t

std::vector<int> arr(3);

vector(initializer_list)

使用初始化列表赋初值

  std::vector<int> v{1, 2, 3, 4};for(auto x : v){std::cout << x << std::endl;}

vector(iterator first, iterator last)

使用[first,last)的元素初始化

  std::list<int> li{1,2,3,4};std::vector<int> v(li.begin(),li.end());for(auto x : v){std::cout << x << std::endl;}

vector(vector other)

拷贝构造

size_t size()

返回vector储存的元素个数

size_t capacity()

返回vector预存的总容量

bool empty()

返回vector是否为空

void push_back(T t)

在vector尾部插入元素t，若capacity() == size()，则先进行capacity的扩容，再尾插

void pop_back()

删除vector尾部元素,当vector为空时，调用该函数会出错

for (int i = 0; i <= 3; i++) {arr.pop_back();
}//会出错

void clear()

清空vector所有元素，但不改变capacity

void resize(size_t length, const T t = T() )

将vector的size修改至length，若length比原来的size()大，多出的元素补t，若比原来的小，则只保留前length个，不改变vector的capacity

void shrink_to_fit();

将capacity收缩至size

arr.shrink_to_fit();

void reserve(size_t t)

将capacity设置为t, 若t<size，则将capacity设置为size

iterator begin()

返回指向vector第一个元素的迭代器，迭代器可以简单理解为指向vector数组对应元素的指针，迭代器支持加减法运算

auto it = arr.begin();
auto it2 = it + 2;
auto it3 = it2 - 1;

iterator end()

返回指向vector最后一个元素的下一个位置的迭代器

iterator rbegin()

返回指向vector最后一个元素的迭代器

iterator rend()

返回指向vector第一个元素前一个位置的迭代器

使用反向迭代器遍历的方法，注意这里是++

  std::vector<int> v(4,5);for(auto it = v.rbegin(); it != v.rend(); it++){std::cout << *it << std::endl;}return 0;

void insert(const iterator it, T t)

在it处插入t, it及其以后的元素全都往后移一位，若在插入后发生扩容，it及其之后的迭代器全部失效，访问以上迭代器属于UB

  std::vector<int> v(3, 3);auto it = v.begin();it++;auto it2 = v.begin();it2++;it2++;v.insert(it, 10);std::cout << *it << ' ' << *it2 << std::endl; //undefined behaviour

void insert(const iterator it, size_t count, T t)

在it处插入count个t

void insert(const iterator it, iterator first, iterator last)

在it处，按顺序插入别的迭代器[first,last)区间的元素，first和last可以是任意容器的迭代器

  std::set<int> s {1,2,3,4};std::vector<int> v{5,6,7,8};v.insert(v.begin() + 2, s.begin(), s.end());for(auto x : v){std::cout << x << std::endl;}

void erase(iterator it)

删除it处的元素

void erase(iterator first, iterator last)

删除[first, last)区间的所有元素

不修改capacity

T& operator[](size_t index)

vector支持下标随机访问

T& at(size_t index)

随机下标访问，但会作边界检查，越界会报错

T& front()

返回第一个元素的引用

T& back()

返回最后一个元素的引用

void emplace_back(...)

传入T的构造函数所需的参数，则直接在vector尾部用这些参数构造该元素

class node{
private:int x, y;
public:node(int a,int b):x{a},y{b}{}friend std::ostream& operator<<(std::ostream& out, const node& u){out << u.x << ' ' << u.y << std::endl;return out;}
};int main(){std::vector<node> v;for (int i = 0; i < 3;i++){v.emplace_back(i, i + 1);}for(auto x:v){std::cout << x;}return 0;
}

void swap(vector& other)

与other交换内容

std::array<class T, size_t N>

构造声明：

其中n必须为编译时常量

std::array<int, n> arr;
std::array<int, n> arr2 = {1, 2, 3};

通用部分

size(), begin(), end(), rbegin(), rend(), swap, empty(), front(), back(), operator[], at()用法与vector一致

size_t max_size()

返回array的容量(数组定义长度)

T* data()

返回执行数组第一个元素的指针

void fill(T t)

用t来填充array

std::list<class T>

构造函数

与vector用法相同

通用部分

size(), empty(), push_back(), pop_back(), clear(), resize(), erase(), insert(), swap(), front(), back() 的用法同vector

push_front(), pop_front()为头插和头删，用法与push_back(), pop_back()类似

void remove(T t)

删除链表中所有值为t的结点

void unique()

去除连续重复数据，只保留一个

std::list<int> li{1,2,2,3,5,3,5};
li.unique();

去重后结果：

1,2,3,5,3,5

void sort(comparator)

给链表排序，默认升序，可传入自定义排序函数或仿函数

  std::list<int> li{1,2,2,3,5,3,5};li.sort([](int a, int b){ return a > b; });for(auto x :li){std::cout << x << std::endl;}

void reverse()

调用后，使链表本身翻转

std::list<int> li{1,2,2,3,5,3,5};
li.reverse();

void merge(list& other)

自身为升序链表，将另外一个升序链表有序合并到自身

void splice(iterator it, list& other)

将other按顺序插入it位置， it为自己的迭代器

void splice(iterator it, list& other, iterator other_it)

将other_it的元素插入it位置, it为自己的迭代器，不知道为什么这里非得传入这个other

void splice(iterator it, list& other, iterator other_first, iterator other_last)

将[first,last)的元素按顺序插入it位置

std::queue<class T, class container = std::deque<T> >

单向队列，可以指定实现容器container

构造函数

无参构造、拷贝构造

void push(T t)

向队尾插入元素t

void pop()

删除队首元素

T& front()、 T& back()

返回队首、队尾元素的引用

通用部分

empty(), size(), swap() 

无迭代器

deque<class T>

双端队列，支持随机访问，头/尾插入/删除效率比vector高

接口与vector几乎一致

只多了push_front(), pop_front()

std::priority_queue<class T, class container = std::vector<T>, class comparator = std::greater<T> >

默认小根堆，comparator传入std::less<T>成为大根堆

构造函数

无参构造、拷贝构造

通用部分

push(), size(), empty(), swap()

void pop()

将堆顶元素删除，并自动调整堆

void top()

获取堆顶元素

std::stack<class T>

构造函数

无参构造、拷贝构造

通用部分

push(), pop(), size(), empty(), swap()

void top()

返回栈顶元素

std::set<class T, class comparator = std::less<T> >

基于红黑树实现集合，不允许重复元素，comparator决定排序顺序

构造函数

同vector

通用部分

begin(), end(), rbegin(), rend(), size(), empty(), clear(), merge()

void erase(...)

迭代器版本与vector一致

这里还可以只传入T t，表示删除值t

void insert(T t)

插入元素t

size_t count(T t)

返回元素t的个数,有即1，无即0

iterator find(T t)

返回元素t的迭代器，元素t不存在则返回end()

iterator lower_bound(T t)

以t作为下界查找set中最小的元素，返回其迭代器， 不存在则返回end()

iterator upper_bound(T t)

返回t的后继的迭代器，不存在则返回end()

std::multiset<class T, ...>

用法与set基本一致，但这里允许插入重复的元素

std::pair<iterator, iterator> equal_range(T t)

返回一对迭代器，first表示t元素组成的数组（简单理解）的begin(), second表示end()，可以用这对迭代器遍历所有的t（虽然其实都是相等的）

void erase(...)

若传入的是T t，则会把全部t都删除

若传入的是迭代器，则只会删除迭代器指向的那个元素

std::map<class Key, class Value>

set<T>的本质可以说就是map<T, T>

因此map的用法和set基本相同

迭代器

map的迭代器解引用返回的是std::pair<Key, Value>

Value operator[](Key key)

支持以key作为下标访问

若key存在，返回对应的value

若key不存在，向map中插入键值对(key, Value())，并返回Value()

Value at(Key key)

作用同operator[], 但key不存在时会抛异常

std::multimap<Key, Value>

相同的键可映射多个Value

接口同multiset

std::string

构造函数

string(char* s)

使用s初始化

string(char* s, size_t  pos, size_t npos)

使用s的pos到pos+npos-1来初始化

string(char* s, size_t npos)

使用s的0到npos-1来初始化

其余构造函数同vector

通用部分

size(), empty(), capacity(), max_size(), resize(), shrink_to_fit(), reserve(), front(), back(), begin(), end(), rbegin(), rend(), opeartor[], at(), reverse()

注：size和length都不计入'\0'

string& append(const string& str)

string& append(const string& str, size_t subpos, size_t sublen)

string& append(const char* s)

string& append(const char* s, size_t n)

string& append(size_t n, char c)

string& append(iterator first, iterator last)

string& operator+=(const string& str)

string& operator+=(const char* s)

string& operator+=(char c)

在字符串后追加传入的参数

const char* c_str()

const char* data()

获取c风格字符串

string& erase(...)

迭代器版本与其他容器一致

string& erase(size_t pos = 0, size_t npos = length)

将下标为pos到pos+npos-1的字符都删除

若pos+npos-1越界，则删到字符串尾部结束

string& insert(size_t pos, const string& str)

string& insert(size_t pos, const string& str, size_t subpos, size_t sublen)

string& insert(size_t pos, const char* s)

string& insert(size_t pos, const char* s, size_t n)

string& insert(size_t pos, size_t n, char c)

void insert(iterator it, size_t n, char c)

iterator insert(iterator it, char c)

void insert(iterator it, iterator first, iterator last)

可以看到，insert就是比append多了第一个pos参数，其他基本一致，表示在pos处append

void assign(...)

std::string operator=(...)

赋值用法

assign和append传参格式相同

+=和=传参格式相同

string substr(size_t pos, size_t len = npos)

返回从pos开始，长度为len的子串

int compare(const string& str)

int compare(size_t pos, size_t len, const string& str)

int compare(size_t pos, size_t len, const string& str, size_t subpos, size_t sublen)

int compare(const char* s)

int compare(size_t pos, size_t len, const char* s)

int compare(size_t pos, size_t len, const char* s, size_t n)

使用自身的pos到pos+len-1的子串与目标的subpos到subpos+sublen-1的子串比较字典序

小于返回-1,等于返回0，大于返回1

size_t find(const string& str, size_t pos = 0)

size_t find(const char* s, size_t pos = 0)

size_t find(const char* s, size_t pos, size_t n)

size_t find(char c, size_t pos = 0)

从pos开始，从左往右找目标串，返回第一个找到的子串首下标，

找不到时，返回SIZE_MAX

第三个重载的n表示s的截取长度

size_t rfind(...)

参数格式与find一致

不过这里是从右往左找

也是返回第一个子串首下标