2021-11-06《C++ Primer》学习记录：第9章（2）——顺序容器的 *** 作：vector、string、deque、list、forward

2021-11-06《C++ Primer》学习记录：第9章（2）——顺序容器的 *** 作：vector、string、deque、list、forward

文章目录

• • • • 9.5 顺序容器的所有 *** 作
      • • 9.5.1 vector
        • 9.5.2 string
        • 9.5.3 deque
        • 9.5.4 list
        • 9.5.5 forward_list
        • 9.5.6 array

9.5 顺序容器的所有 *** 作 9.5.1 vector

​ vector 将元素连续存储，每个元素紧挨着前一个元素存储。

​ vector 预留一些空间作为备用，用来保存更多的新元素。当需求大小大于当前容量时，才会调用 reserve 来改变其容量，每次将容量增加至原来的 2 倍。

​ vector 的扩张 *** 作通常比 list 和 deque 还要快。

成员说明成员类型value_type元素类型 Tallocator_type分配器类型reference / const_referencevalue_type& / const value_type&pointer / const_pointer指针 / 常量指针iterator / const_iterator迭代器 / 常量迭代器reverse_iterator / const_reverse_iterator反向迭代器 / 常量反向迭代器size_type / difference_type元素个数的类型 / 迭代器距离的类型获取迭代器iterator begin() / rbegin() noexcept;
const_iterator begin() / rbegin() const noexcept;返回指向首元素 / 尾元素的迭代器iterator end() / rend() noexcept;
const_iterator end() / rend() const noexcept;返回指向尾后元素 / 首前元素的迭代器const_iterator cbegin() / crbegin() const noexcept;返回指向首元素 / 尾元素的常量迭代器const_iterator cend() / crend() const noexcept;返回指向尾后元素 / 首前元素的常量迭代器构造函数explicit vector (const allocator_type& alloc = allocator_type());默认构造函数explicit vector (size_type n);指定容器大小为 nvector (size_type n, const value_type& val, const allocator_type& alloc = allocator_type());指定容器大小为 n，每个值都为 valtemplate
vector (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());顺序构建与给定范围一样元素的容器vector (const vector& x);
vector (vector&& x);复制 vector xvector (const vector& x, const allocator_type& alloc);
vector (vector&& x, const allocator_type& alloc);复制 vector x，并指定分配器 allocvector (const vector& x, const allocator_type& alloc);
vector (initializer_list il, const allocator_type& alloc = allocator_type());使用列表构建元素赋值运算符vector& operator= (const vector& x);
vector& operator= (vector&& x);以 vector x 的内容进行赋值vector& operator= (initializer_list il);用列表元素进行赋值容量函数size_type size() const noexcept;返回 vector 大小size_type max_size() const noexcept;返回所能容纳的最大元素数量void resize (size_type n);
void resize (size_type n, const value_type& val);调整容器大小，使其包含 n 个元素
若 n 大于当前大小，则进行扩容，指定扩展部分的值为 val
若 n 小于当前大小，删除尾部多出的元素size_type capacity() const noexcept;返回目前分配的存储空间的大小bool empty() const noexcept;判断 vector 是否为空void reserve (size_type n);使其容量增加到 nvoid shrink_to_fit();要求容器降低容量以适应其大小获取元素reference operator[] (size_type n);
const_reference operator[] (size_type n) const;返回第 n 个位置的元素引用，
越界行为未定义reference at (size_type n);
const_reference at (size_type n) const;返回第 n 个位置的元素引用，
越界会抛出异常reference front();
const_reference front() const;返回第一个元素的引用reference back();
const_reference back() const;返回最后一个元素的引用value_type* data() noexcept;
const value_type* data() const noexcept;返回一个指针，该指针指向内部用于存储元素的内存数组修改容器template
void assign (InputIterator first, InputIterator last);
void assign (size_type n, const value_type& val);
void assign (initializer_list il);赋值 *** 作，分别对 vector 进行
范围 /
n 个 val 值 /
列表
赋值void push_back (const value_type& val);
void push_back (value_type&& val);在末尾添加元素 valvoid pop_back();删除末尾元素iterator insert (const_iterator position, const value_type& val);
iterator insert (const_iterator position, value_type&& val);
iterator insert (const_iterator position, size_type n, const value_type& val);
template
iterator insert (const_iterator position, InputIterator first, InputIterator last);
iterator insert (const_iterator position, initializer_list il);在迭代器 position 位置之前，分别插入
一个 val 值 /
n 个 val 值 /
范围 /
列表值iterator erase (const_iterator position);
iterator erase (const_iterator first, const_iterator last);移除迭代器所给定的位置 / 范围void swap (vector& x);与 vector x 交换内容void clear() noexcept;清除所有的内容template
iterator emplace (const_iterator position, Args&&… args);在迭代器 position 之前插入元素，该元素由参数 args 通过构造函数进行构造template
void emplace_back (Args&&… args);在末尾插入元素，该元素由参数 args 通过构造函数进行构造获取分配器器allocator_type get_allocator() const noexcept;返回分配器对象的副本 重载的非成员函数说明template
bool operator _op (const vector& lhs, const vector& rhs);重载 6 个关系运算符，
_ op 可以是 <，<=，>，>=，==，!=template
void swap (vector& x, vector& y);交换 x 与 y 的内容 9.5.2 string 成员说明成员类型value_typechartraits_typechar_traitsallocator_typeallocatorreference / const_referencechar& / const char&pointer / const_pointerchar* / const char*iterator / const_iterator迭代器 / 常量迭代器reverse_iterator / const_reverse_iterator反向迭代器 / 常量反向迭代器size_type / difference_typeptrdiff_t / size_tnposstatic const size_t npos = -1;获取迭代器iterator begin() / rbegin() noexcept;
const_iterator begin() / rbegin() const noexcept;返回指向首元素 / 尾元素的迭代器iterator end() / rend() noexcept;
const_iterator end() / rend() const noexcept;返回指向尾后元素 / 首前元素的迭代器const_iterator cbegin() / crbegin() const noexcept;返回指向首元素 / 尾元素的常量迭代器const_iterator cend() / crend() const noexcept;返回指向尾后元素 / 首前元素的常量迭代器构造函数string();默认构造函数string (const string& str);拷贝构造函数string (const string& str, size_t pos, size_t len = npos);复制从字符位置开始的 str 部分，该部分将跨越 len 字符string (const char* s);复制由 s （C 字符串）指出的空终止字符序列string (const char* s, size_t n);复制由 s （C 字符串）指出的前 n 个字符序列string (size_t n, char c);构造连续 n 个 c 的stringtemplate
string (InputIterator first, InputIterator last);以相同的顺序复制范围中的字符序列string (initializer_list il);以相同的顺序复制每个字符string (string&& str) noexcept;移动构造函数赋值运算符string& operator= (const string& str);分配新值，内容由 str 给出string& operator= (const char* s);分配新值，内容由 s 指出的空终止字符序列 给出string& operator= (char c);分配新值，内容为单个字符 cstring& operator= (initializer_list il);分配新值，内容由列表 il 给出string& operator= (string&& str) noexcept;分配新值，内容由 str 给出容量函数size_t size() const noexcept;按字节返回字符串的长度size_t length() const noexcept;按字节返回字符串的长度size_t max_size() const noexcept;返回字符串可以达到的最大长度void resize (size_type n);
void resize (size_type n, char c);将字符串调整为 n 字符的长度
若 n 大于当前长度，则在末尾插入 c 字符，默认为空字符
若 n 小于当前长度，则截断后面多出的字符size_t capacity() const noexcept;返回目前分配的存储空间的大小bool empty() const noexcept;判断 string 是否为空void reserve (size_t n = 0);使其容量增加到 nvoid shrink_to_fit();要求字符串降低容量以适应其大小获取元素char& operator[] (size_t pos);
const char& operator[] (size_t pos) const;返回第 pos 个字符的引用，
越界行为未定义char& at (size_t pos);
const char& at (size_t pos) const;返回第 pos 个字符的引用，
越界会抛出异常char& front();
const char& front() const;返回第一个元素的引用char& back();
const char& back() const;返回最后一个元素的引用const char* data() const noexcept;返回指向字符串对象当前用于存储符合其值的字符的内部数组。
功能同 c_str()修改字符串string& operator+= (const string& str);
string& operator+= (const char* s);
string& operator+= (char c);
string& operator+= (initializer_list il);在其末尾附加字符 / 字符串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);
template
string& append (InputIterator first, InputIterator last);
string& append (initializer_list il);在其末尾附加字符 / 字符串void push_back (char c);将字符 c 附在字符串的末尾，将其长度增加一个string& assign (const string& str);
string& assign (const string& str, size_t subpos, size_t sublen);
string& assign (const char* s);
string& assign (const char* s, size_t n);
string& assign (size_t n, char c);
template
string& assign (InputIterator first, InputIterator last);
string& assign (initializer_list il);
string& assign (string&& str) noexcept;为字符串分配新值，以取代其当前内容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);
iterator insert (const_iterator p, size_t n, char c);
iterator insert (const_iterator p, char c);
template
iterator insert (iterator p, InputIterator first, InputIterator last);
string& insert (const_iterator p, initializer_list il);在 pos（或 p）指示的字符之前，插入字符 / 字符串string& erase (size_t pos = 0, size_t len = npos);
iterator erase (const_iterator p);
iterator erase (const_iterator first, const_iterator last);擦除字符串的一部分string& replace (size_t pos, size_t len, const string& str);
string& replace (const_iterator i1, const_iterator i2, const string& str);
string& replace (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen);
string& replace (size_t pos, size_t len, const char* s);
string& replace (const_iterator i1, const_iterator i2, const char* s);
string& replace (size_t pos, size_t len, const char* s, size_t n);
string& replace (const_iterator i1, const_iterator i2, const char* s, size_t n);
string& replace (size_t pos, size_t len, size_t n, char c);
string& replace (const_iterator i1, const_iterator i2, size_t n, char c);
template
string& replace (const_iterator i1, const_iterator i2, InputIterator first, InputIterator last);
string& replace (const_iterator i1, const_iterator i2, initializer_list il);以新内容替换从字符 pos 开始的字符部分，并按新内容跨度字符void clear() noexcept;擦除字符串的内容，变为空串void swap (string& str);与 str 交换内容void pop_back();擦除最后一个字符，
若字符串为空，则行为未定义string *** 作const char* c_str() const noexcept;返回指向字符串对象当前用于存储符合其值的字符的内部数组。
功能同 data()size_t copy (char* s, size_t len, size_t pos = 0) const;从 s 中拷贝指定位置 pos 开始的所有字符size_t find (const string& str, size_t pos = 0) const noexcept;
size_t find (const char* s, size_t pos = 0) const;
size_t find (const char* s, size_t pos, size_type n) const;
size_t find (char c, size_t pos = 0) const noexcept;顺序搜索首次出现的字符 / 字符串：
pos：指定位置开始
n：匹配字符序列的长度size_t rfind (const string& str, size_t pos = npos) const noexcept;
size_t rfind (const char* s, size_t pos = npos) const;
size_t rfind (const char* s, size_t pos, size_t n) const;
size_t rfind (char c, size_t pos = npos) const noexcept;逆序搜索首次出现的字符 / 字符串：
pos：指定位置开始
n：匹配字符序列的长度size_t find_first_of (const string& str, size_t pos = 0) const noexcept;
size_t find_first_of (const char* s, size_t pos = 0) const;
size_t find_first_of (const char* s, size_t pos, size_t n) const;
size_t find_first_of (char c, size_t pos = 0) const noexcept;返回字符串中出现的第一个包含在 str / s / c 中的字符位置：
pos：指定位置开始
n：匹配字符序列的长度size_t find_last_of (const string& str, size_t pos = npos) const noexcept;
size_t find_last_of (const char* s, size_t pos = npos) const;
size_t find_last_of (const char* s, size_t pos, size_t n) const;
size_t find_last_of (char c, size_t pos = npos) const noexcept;返回字符串中出现的最后一个包含在 str / s / c 中的字符位置：
pos：指定位置开始
n：匹配字符序列的长度size_t find_first_not_of (const string& str, size_t pos = 0) const noexcept;
size_t find_first_not_of (const char* s, size_t pos = 0) const;
size_t find_first_not_of (const char* s, size_t pos, size_t n) const;
size_t find_first_not_of (char c, size_t pos = 0) const noexcept;返回字符串中出现的第一个不包含在 str / s / c 中的字符位置：
pos：指定位置开始
n：匹配字符序列的长度size_t find_last_not_of (const string& str, size_t pos = npos) const noexcept;
size_t find_last_not_of (const char* s, size_t pos = npos) const;
size_t find_last_not_of (const char* s, size_t pos, size_t n) const;
size_t find_last_not_of (char c, size_t pos = npos) const noexcept;返回字符串中出现的最后一个不包含在 str / s / c 中的字符位置：
pos：指定位置开始
n：匹配字符序列的长度string substr (size_t pos = 0, size_t len = npos) const;返回起始位置为 pos，长度为 len 的子串。
若超出范围，则返回 pos 后所有字符组成的 stringint compare (const string& str) const noexcept;
int compare (size_t pos, size_t len, const string& str) const;
int compare (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen) const;
int compare (const char* s) const;
int compare (size_t pos, size_t len, const char* s) const;
int compare (size_t pos, size_t len, const char* s, size_t n) const;如果相等则返回 0，比给定字符串大则返回 1，比给定字符串小则返回 -1获取分配器allocator_type get_allocator() const noexcept;返回分配器对象的副本 非成员函数说明重载函数string operator+ (const string& lhs, const string& rhs);
string operator+ (string&& lhs, string&& rhs);
string operator+ (string&& lhs, const string& rhs);
string operator+ (const string& lhs, string&& rhs);
string operator+ (const string& lhs, const char* rhs);
string operator+ (string&& lhs, const char* rhs);
string operator+ (const char* lhs, const string& rhs);
string operator+ (const char* lhs, string&& rhs);
string operator+ (const string& lhs, char rhs);
string operator+ (string&& lhs, char rhs);
string operator+ (char lhs, const string& rhs);
string operator+ (char lhs, string&& rhs);重载 + 运算符，连接字符串 / 字符bool operator_op (const string& lhs, const string& rhs);
bool operator_op (const char* lhs, const string& rhs);
bool operator_op (const string& lhs, const char* rhs);重载 6 个关系运算符，
_op 可以是 <，<=，>，>=，==，!=void swap (string& x, string& y);交换 x 和 y 的内容istream& operator>> (istream& is, string& str);
ostream& operator<< (ostream& os, const string& str);重载字符串的输入和输出 *** 作istream& getline (istream& is, string& str, char delim);
istream& getline (istream&& is, string& str, char delim);
istream& getline (istream& is, string& str);
istream& getline (istream&& is, string& str);读取字符串，直到遇到字符 delim 为止。
默认 delim 为 ‘n’，因此默认读取一行字符串转换函数string to_string (Type val);将 val 值转换为 string，val 的类型 Type 可以是：
(unsigned) int;
(unsigned) long;
(unsigned) long long;
float;
(long) double;Type sto_type (const string& str, size_t* idx = 0, int base = 10);
Type sto_type (const wstring& str, size_t* idx = 0, int base = 10);将 string 转换为其他类型 Type，_type 为 Type 的简写。可以转换的类型有：
int;
(unsigned) long;
(unsigned) long long;

idx：str 中开始转化的位置，默认为第一个字符开始
base：使用的进制，默认为 10 进制Type sto_type (const string& str, size_t* idx = 0);
Type sto_type (const wstring& str, size_t* idx = 0);将 string 转换为其他类型 Type，_type 为 Type 的简写。可以转换的类型有：
float
(long) double

idx：str 中开始转化的位置，默认为第一个字符开始 9.5.3 deque 成员说明成员类型value_type元素类型 Tallocator_type分配器类型reference / const_referencevalue_type& / const value_type&pointer / const_pointer指针 / 常量指针iterator / const_iterator迭代器 / 常量迭代器reverse_iterator / const_reverse_iterator反向迭代器 / 常量反向迭代器size_type / difference_type元素个数的类型 / 迭代器距离的类型构造函数explicit deque (const allocator_type& alloc = allocator_type());默认构造函数explicit deque (size_type n);指定 deque 的大小为 ndeque (size_type n, const value_type& val, const allocator_type& alloc = allocator_type());指定 deque 的大小为 n，每个元素的值为 valtemplate
deque (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());使用范围构造 dequedeque (const deque& x);
deque (const deque& x, const allocator_type& alloc);拷贝构造函数，可指定分配器deque (deque&& x);
deque (deque&& x, const allocator_type& alloc);移动构造函数，可指定分配器deque (initializer_list il, const allocator_type& alloc = allocator_type());使用列表构造 deque获取迭代器iterator begin() / rbegin() noexcept;
const_iterator begin() / rbegin() const noexcept;返回指向首元素 / 尾元素的迭代器iterator end() / rend() noexcept;
const_iterator end() / rend() const noexcept;返回指向尾后元素 / 首前元素的迭代器const_iterator cbegin() / crbegin() const noexcept;返回指向首元素 / 尾元素的常量迭代器const_iterator cend() / crend() const noexcept;返回指向尾后元素 / 首前元素的常量迭代器赋值运算符deque& operator= (const deque& x);
deque& operator= (deque&& x);将 x 赋值给 dequedeque& operator= (initializer_list il);使用列表进行赋值容量函数size_type size() const noexcept;返回 deque 大小size_type max_size() const noexcept;返回所能容纳的最大元素数量void resize (size_type n);
void resize (size_type n, const value_type& val);调整容器大小，使其包含 n 个元素
若 n 大于当前大小，则进行扩容，指定扩展部分的值为 val
若 n 小于当前大小，删除尾部多出的元素bool empty() const noexcept;判断 deque 是否为空void shrink_to_fit();要求容器降低容量以适应其大小获取元素reference operator[] (size_type n);
const_reference operator[] (size_type n) const;返回第 n 个位置的元素引用，
越界行为未定义reference at (size_type n);
const_reference at (size_type n) const;返回第 n 个位置的元素引用，
越界会抛出异常reference front();
const_reference front() const;返回第一个元素的引用reference back();
const_reference back() const;返回最后一个元素的引用修改容器template
void assign (InputIterator first, InputIterator last);
void assign (size_type n, const value_type& val);
void assign (initializer_list il);赋值 *** 作，分别对 deque 进行
范围 /
n 个 val 值 /
列表
赋值void push_back (const value_type& val);
void push_back (value_type&& val);在末尾添加元素 valvoid push_front (const value_type& val);
void push_front (value_type&& val);在开头添加元素 valvoid pop_back();删除末尾元素void pop_front();删除开头元素iterator insert (const_iterator position, const value_type& val);
iterator insert (const_iterator position, value_type&& val);
iterator insert (const_iterator position, size_type n, const value_type& val);
template
iterator insert (const_iterator position, InputIterator first, InputIterator last);
iterator insert (const_iterator position, initializer_list il);在迭代器 position 位置之前，分别插入
一个 val 值 /
n 个 val 值 /
范围 /
列表值iterator erase (const_iterator position);
iterator erase (const_iterator first, const_iterator last);移除迭代器所给定的位置 / 范围void swap (deque& x);与 deque x 交换内容void clear() noexcept;清除所有的内容template
iterator emplace (const_iterator position, Args&&… args);在迭代器 position 之前插入元素，该元素由参数 args 通过构造函数进行构造template
void emplace_back (Args&&… args);在末尾插入元素，该元素由参数 args 通过构造函数进行构造template
void emplace_front (Args&&… args);在开头插入元素，该元素由参数 args 通过构造函数进行构造获取分配器allocator_type get_allocator() const noexcept;返回分配器对象的副本 重载的非成员函数说明template
bool operator _op (const deque& lhs, const deque& rhs);重载 6 个关系运算符，
_op 可以是 <，<=，>，>=，==，!=template
void swap (deque& x, deque& y);交换 x 与 y 的内容 9.5.4 list 成员说明成员类型value_type元素类型 Tallocator_type分配器类型reference / const_referencevalue_type& / const value_type&pointer / const_pointer指针 / 常量指针iterator / const_iterator迭代器 / 常量迭代器reverse_iterator / const_reverse_iterator反向迭代器 / 常量反向迭代器size_type / difference_type元素个数的类型 / 迭代器距离的类型获取迭代器iterator begin() / rbegin() noexcept;
const_iterator begin() / rbegin() const noexcept;返回指向首元素 / 尾元素的迭代器iterator end() / rend() noexcept;
const_iterator end() / rend() const noexcept;返回指向尾后元素 / 首前元素的迭代器const_iterator cbegin() / crbegin() const noexcept;返回指向首元素 / 尾元素的常量迭代器const_iterator cend() / crend() const noexcept;返回指向尾后元素 / 首前元素的常量迭代器构造函数explicit list (const allocator_type& alloc = allocator_type());默认构造函数explicit list (size_type n);指定 list 大小为 nlist (size_type n, const value_type& val, const allocator_type& alloc = allocator_type());指定 list 大小为 n，每个元素的值为 valtemplate
list (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());指定范围构造 listlist (const list& x);
list (const list& x, const allocator_type& alloc);拷贝构造函数，可指定分配器list (list&& x);
list (list&& x, const allocator_type& alloc);移动构造函数，可指定分配器list (initializer_list il, const allocator_type& alloc = allocator_type());使用列表构造 listlist& operator= (const list& x);
list& operator= (list&& x);将 x 赋值给 listlist& operator= (initializer_list il);使用列表进行赋值容量函数size_type size() const noexcept;返回 list 大小size_type max_size() const noexcept;返回所能容纳的最大元素数量bool empty() const noexcept;判断 list 是否为空获取元素reference front();
const_reference front() const;返回第一个元素的引用reference back();
const_reference back() const;返回最后一个元素的引用修改容器template
void assign (InputIterator first, InputIterator last);
void assign (size_type n, const value_type& val);
void assign (initializer_list il);赋值 *** 作，分别对 list 进行
范围 /
n 个 val 值 /
列表
赋值template
void emplace_front (Args&&… args);在开头插入元素，该元素由参数 args 通过构造函数进行构造template
void emplace_back (Args&&… args);在末尾插入元素，该元素由参数 args 通过构造函数进行构造void push_front (const value_type& val);
void push_front (value_type&& val);在开头插入元素，值为 valvoid push_back (const value_type& val);
void push_back (value_type&& val);在末尾插入元素，值为 valvoid pop_front();删除开头元素void pop_back();删除末尾元素iterator insert (const_iterator position, const value_type& val);
iterator insert (const_iterator position, value_type&& val);
iterator insert (const_iterator position, size_type n, const value_type& val);
template
iterator insert (const_iterator position, InputIterator first, InputIterator last);
iterator insert (const_iterator position, initializer_list il);在迭代器 position 位置之前，分别插入
一个 val 值 /
n 个 val 值 /
范围 /
列表值void resize (size_type n);
void resize (size_type n, const value_type& val);调整容器大小，使其包含 n 个元素
若 n 大于当前大小，则进行扩容，指定扩展部分的值为 val
若 n 小于当前大小，删除尾部多出的元素iterator erase (const_iterator position);
iterator erase (const_iterator first, const_iterator last);移除迭代器所给定的位置 / 范围void swap (list& x);与 list x 交换内容void clear() noexcept;清除所有的内容 *** 作 listvoid splice (const_iterator position, list& x);
void splice (const_iterator position, list&& x);
void splice (const_iterator position, list& x, const_iterator i);
void splice (const_iterator position, list&& x, const_iterator i);
void splice (const_iterator position, list& x, const_iterator first, const_iterator last);
void splice (const_iterator position, list&& x, const_iterator first, const_iterator last);实现 list 拼接的功能。将 x 的内容部分或全部元素删除，拼插入到目的 list 的 position 之后void remove (const value_type& val);从容器中取出所有与 val 相等的元素并删除template
void remove_if (Predicate pred);从容器中取出所有满足谓词 pred 的元素并删除void unique();
template
void unique (BinaryPredicate binary_pred);将元素与其前一个元素进行比较，若相等则删除，
若指定了第二参数，则使用 二元谓词 binary_pred 判断是否删除元素void merge (list& x);
void merge (list&& x);
template
void merge (list& x, Compare comp);
template
void merge (list&& x, Compare comp);
合并两个有序列表，合并后 x 中的所有元素将被删除。
若指定谓词 comp，则按照 comp 进行合并
（通常使用之前会先 sort() 使其有序）void sort();
template
void sort (Compare comp);对 list 进行排序。
若指定谓词 comp，则按照 comp 进行排序void reverse() noexcept;反转列表容器中元素的顺序获取分配器allocator_type get_allocator() const noexcept;返回分配器对象的副本 重载的非成员函数说明template
bool operator _op (const list& lhs, const list& rhs);重载 6 个关系运算符，
_op 可以是 <，<=，>，>=，==，!=template
void swap (list& x, list& y);交换 x 与 y 的内容 9.5.5 forward_list 成员说明成员类型value_type元素类型 Tallocator_type分配器类型reference / const_referencevalue_type& / const value_type&pointer / const_pointer指针 / 常量指针iterator / const_iterator迭代器 / 常量迭代器size_type / difference_type元素个数的类型 / 迭代器距离的类型获取迭代器iterator begin() noexcept;
const_iterator begin() const noexcept;返回指向首元素的迭代器iterator end() noexcept;
const_iterator end() const noexcept;返回指向尾后元素的迭代器iterator before_begin() noexcept;
const_iterator before_begin() const noexcept;返回指向首前元素的迭代器const_iterator cbegin() const noexcept;返回指向首元素常量迭代器const_iterator cend() const noexcept;返回指向尾后元素的常量迭代器const_iterator cbefore_begin() const noexcept;返回指向首前元素的常量迭代器构造函数explicit forward_list (const allocator_type& alloc = allocator_type());默认构造函数explicit forward_list (size_type n);
explicit forward_list (size_type n, const value_type& val, const allocator_type& alloc = allocator_type());指定构造 n 个元素，每个元素的值为 valtemplate
forward_list (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());根据范围构造 forward_listforward_list (const forward_list& fwdlst);
forward_list (const forward_list& fwdlst, const allocator_type& alloc);拷贝构造函数，可指定分配器forward_list (forward_list&& fwdlst);
forward_list (forward_list&& fwdlst, const allocator_type& alloc);移动构造函数，可指定分配器forward_list (initializer_list il, const allocator_type& alloc = allocator_type());使用列表构造赋值运算符forward_list& operator= (const forward_list& fwdlst);
forward_list& operator= (forward_list&& fwdlst);将 fwdlst 的内容赋值给 forward_listforward_list& operator= (initializer_list il);使用列表赋值容量函数bool empty() const noexcept;判断 forward_list 是否为空size_type max_size () const noexcept;返回所能容纳的最大元素数量获取元素reference front();
const_reference front() const;返回第一个元素的引用修改容器template
void assign (InputIterator first, InputIterator last);
void assign (size_type n, const value_type& val);
void assign (initializer_list il);赋值 *** 作，分别对 forward_list 进行
范围 /
n 个 val 值 /
列表
赋值template
void emplace_front (Args&&… args);在开头插入元素，该元素由参数 args 通过构造函数进行构造void push_front (const value_type& val);
void push_front (value_type&& val);在开头插入元素，值为 valvoid pop_front();删除开头元素template
iterator emplace_after (const_iterator position, Args&&… args);在 position 之后插入元素，使用 args 参数构造该元素iterator insert_after (const_iterator position, const value_type& val);
iterator insert_after (const_iterator position, value_type&& val);
iterator insert_after (const_iterator position, size_type n, const value_type& val);
template
iterator insert_after (const_iterator position, InputIterator first, InputIterator last);
iterator insert_after (const_iterator position, initializer_list il);在迭代器 position 位置之后，分别插入
一个 val 值 /
n 个 val 值 /
范围 /
列表值void resize (size_type n);
void resize (size_type n, const value_type& val);调整容器大小，使其包含 n 个元素
若 n 大于当前大小，则进行扩容，指定扩展部分的值为 val
若 n 小于当前大小，删除尾部多出的元素iterator erase_after (const_iterator position);
iterator erase_after (const_iterator first, const_iterator last);移除迭代器所给定的位置 / 范围void swap (forward_list& x);与 forward_list x 交换内容void clear() noexcept;清除所有的内容 *** 作 forward_listvoid splice_after (const_iterator position, forward_list& fwdlst);
void splice_after (const_iterator position, forward_list&& fwdlst);
void splice_after (const_iterator position, forward_list& fwdlst, const_iterator i);
void splice_after (const_iterator position, forward_list&& fwdlst, const_iterator i);
void splice_after (const_iterator position, forward_list& fwdlst, const_iterator first, const_iterator last);
void splice_after (const_iterator position, forward_list&& fwdlst, const_iterator first, const_iterator last);实现 forward_list 拼接的功能。将 fwdlst 的内容部分或全部元素删除，拼插入到目的 forward_list 的 position 之后void remove (const value_type& val);从容器中取出所有与 val 相等的元素并删除template
void remove_if (Predicate pred);从容器中取出所有满足谓词 pred 的元素并删除void unique();
template
void unique (BinaryPredicate binary_pred);将元素与其前一个元素进行比较，若相等则删除，
若指定了第二参数，则使用 二元谓词 binary_pred 判断是否删除元素void merge (forward_list& fwdlst);
void merge (forward_list&& fwdlst);
template
void merge (forward_list& fwdlst, Compare comp);
template
void merge (forward_list&& fwdlst, Compare comp);
合并两个有序列表，合并后 fwdlst 中的所有元素将被删除。
若指定谓词 comp，则按照 comp 进行合并
（通常使用之前会先 sort() 使其有序）void sort();
template
void sort (Compare comp);对 list 进行排序。
若指定谓词 comp，则按照 comp 进行排序void reverse() noexcept;反转列表容器中元素的顺序获取分配器allocator_type get_allocator() const noexcept;返回分配器对象的副本 重载的非成员函数说明template
bool operator _op (const forward_list& lhs, const forward_list& rhs);重载 6 个关系运算符，
_op 可以是 <，<=，>，>=，==，!=template
void swap (forward_list& x, forward_list& y);交换 x 与 y 的内容 9.5.6 array 成员说明成员类型value_type元素类型 Treference / const_referencevalue_type& / const value_type&pointer / const_pointer指针 / 常量指针iterator / const_iterator迭代器 / 常量迭代器reverse_iterator / const_reverse_iterator反向迭代器 / 常量反向迭代器size_type / difference_type元素个数的类型 / 迭代器距离的类型获取迭代器iterator begin() / rbegin() noexcept;
const_iterator begin() / rbegin() const noexcept;返回指向首元素 / 尾元素的迭代器iterator end() / rend() noexcept;
const_iterator end() / rend() const noexcept;返回指向尾后元素 / 首前元素的迭代器const_iterator cbegin() / crbegin() const noexcept;返回指向首元素 / 尾元素的常量迭代器const_iterator cend() / crend() const noexcept;返回指向尾后元素 / 首前元素的常量迭代器容量函数size_type size() const noexcept;返回 array 大小size_type max_size() const noexcept;返回所能容纳的最大元素数量bool empty() const noexcept;判断 array 是否为空获取元素reference operator[] (size_type n);
const_reference operator[] (size_type n) const;返回第 n 个位置的元素引用，
越界行为未定义reference at (size_type n);
const_reference at (size_type n) const;返回第 n 个位置的元素引用，
越界会抛出异常reference front();
const_reference front() const;返回第一个元素的引用reference back();
const_reference back() const;返回最后一个元素的引用value_type* data() noexcept;
const value_type* data() const noexcept;返回一个指针，该指针指向内部用于存储元素的内存数组修改容器void fill (const value_type& val);用 val 填满 arrayvoid swap (array& x) noexcept;交换与 x 的内容

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/5426695.html