文章目录

• • 一、string容器
  • 二、vector容器
  • 三、list容器
  • • 1.构造函数
    • 2.特性操作
    • 3.元素操作
    • 4.赋值操作
    • 5.交换、反转、排序、归并
    • 6.比较操作
  • 7.插入和删除
  • 四、pair键值对
  • 五、map容器
  • • 1.红黑树（平衡二叉排序树）
    • 2.构造函数
    • 3.特性操作
    • 4.元素操作
    • 5.赋值操作
    • 6.交换操作
    • 7.比较操作
    • 8.查找操作
    • 9.插入和删除
  • 六、unordered_map容器
  • • 1.哈希表
    • 2.构造函数
    • 3.特性操作
    • 4.元素操作
    • 5.赋值操作
    • 6.交换操作
    • 7.比较操作
    • 8.查找操作
    • 9.插入和删除
  • 六、queue容器
  • • 1.构造函数
    • 2.常用操作
    • 3.其他操作
  • 七、STL其他容器
  • • 1.array（静态数组）

一、string容器

二、vector容器

三、list容器

1.构造函数

• 本质是双向链表

1）list();  // 创建一个空的list容器。
2）list(initializer_list il); // 使用统一初始化列表。
3）list(const list& l);  // 拷贝构造函数。
4）list(Iterator first, Iterator last);  // 用迭代器创建list容器。
5）list(list&& l);  // 移动构造函数（C++11标准）。不常用：
6）explicit list(const size_t n);   // 创建list容器，元素个数为n。
7）list(const size_t n, const T& value);  // 创建list容器，元素个数为n，值均为value。

• eg：

#include 
#include 
#include 
using  namespace std;int main()
{// 1）list();  // 创建一个空的list容器。list l1;// cout << "li.capacity()=" << l1.capacity() << endl;  // 链表没有容量说法。不需要提前分配内存cout << "li.size()=" << l1.size() << endl;// 2）list(initializer_list il); // 使用统一初始化列表。list l2({ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });// list l2={ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };// list l2  { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };for (int value : l2)       // 用基于范围的for循环遍历容器。cout << value << " ";cout << endl;// 3）list(const list& l);  // 拷贝构造函数。list l3(l2);// list l3=l2;for (int value : l3)    cout << value << " ";cout << endl;// 4）list(Iterator first, Iterator last);  // 用迭代器创建list容器。//list l4(l3.begin(), l3.end()-3);  error，不支持随机访问：list l4(l3.begin(), l3.end());      // 用list容器的迭代器。for (int value : l4)  cout << value << " ";cout << endl;vector v1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };  // 创建vector容器。list l5(v1.begin() + 2, v1.end() - 3);          // 用vector容器的迭代器创建list容器。for (int value : l5)   cout << value << " ";cout << endl;int a1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };   // 创建数组。数组的指针是天然的随机访问迭代器//	list l6(std::begin(a1) + 2, std::end(a1) + 10 - 3);   list l6(a1 + 2, a1 + 10 - 3);           // 用数组的指针作为迭代器创建list容器。for (int value : l6)     cout << value << " ";cout << endl;char str[] = "hello world";         // 定义C风格字符串。string s1(str + 1, str + 7);          // 用C风格字符串创建string容器。for (auto value : s1)                   // 遍历string容器。cout << value << " ";cout << endl;cout << s1 << endl;                 // 以字符串的方式显示string容器。vector v2(l3.begin(), l3.end());   // 用list迭代器创建vector容器。for (auto value : v2)                               // 遍历vector容器。cout << value << " ";cout << endl;
}

2.特性操作

size_t size() const;        // 返回容器的实际大小（已使用的空间）。
bool empty() const;      // 判断容器是否为空。
void clear();             // 清空容器。
void resize(size_t size);   // 把容器的实际大小置为size。不常用：
size_t max_size() const;     // 返回容器的最大长度，此函数意义不大。
void resize(size_t size,const T &value);  // 把容器的实际大小置为size，如果size<实际大小，会截断多出的部分；如果size>实际大小，就用value填充。

3.元素操作

T &front();        // 第一个元素。
const T &front();  // 第一个元素，只读。
const T &back();  // 最后一个元素，只读。
T &back();        // 最后一个元素。

4.赋值操作

给已存在的容器赋值，将覆盖容器中原有的内容。

1）list &operator=(const list &l);         // 把容器l赋值给当前容器。
2）list &operator=(initializer_list il);  // 用统一初始化列表给当前容器赋值。
3）list assign(initializer_list il);        // 使用统一初始化列表赋值。
4）list assign(Iterator first, Iterator last);  // 用迭代器赋值。不常用：
5）void assign(const size_t n, const T& value);  // 把n个value给容器赋值。

5.交换、反转、排序、归并

void swap(list &l);   // 把当前容器与l交换，交换的是链表结点的地址。
void reverse();           // 反转链表。
void sort();              // 对容器中的元素进行升序排序。
void sort(_Pr2 _Pred);    // 对容器中的元素进行排序，排序的方法由_Pred决定（二元函数）。
void merge(list &l);  // 采用归并法合并两个已排序的list容器，合并后的list容器仍是有序的。

• eg：

#include 
#include 
#include 
using  namespace std;int main()
{list  la = { 8,2,6,4,5 };for (auto &val : la)cout << val << " ";cout << endl;la.reverse();      // 反转链表。for (auto& val : la)cout << val << " ";cout << endl;la.sort();            // 链表排序。for (auto& val : la)cout << val << " ";cout << endl;list  lb = { 3,7,9,10,1 };lb.sort();            // 链表排序。la.merge(lb);    // 归并链表。for (auto& val : la)cout << val << " ";cout << endl;
}

6.比较操作

bool operator == (const vector & l) const;
bool operator != (const vector & l) const;

7.插入和删除

1）void push_back(const T& value);  // 在链表的尾部追加一个元素。
2）void emplace_back(…);           // 在链表的尾部追加一个元素，…用于构造元素。C++11
3）iterator insert(iterator pos, const T& value);  // 在指定位置插入一个元素，返回指向插入元素的迭代器。
4）iterator emplace (iterator pos, …);  // 在指定位置插入一个元素，…用于构造元素，返回指向插入元素的迭代器。C++11
5）iterator insert(iterator pos, iterator first, iterator last);  // 在指定位置插入一个区间的元素，返回指向第一个插入元素的迭代器。
6）void pop_back();                      // 从链表尾部删除一个元素。
7）iterator erase(iterator pos);             // 删除指定位置的元素，返回下一个有效的迭代器。
8）iterator erase(iterator first, iterator last); // 删除指定区间的元素，返回下一个有效的迭代器。
9）push_front(const T& value);  // 在链表的头部插入一个元素。
10）emplace_front(…);          // 在链表的头部插入一个元素，…用于构造元素。C++11
11）splice(iterator pos, const list & l);	  // 把另一个链表连接到当前链表。
12）splice(iterator pos, const list & l, iterator first, iterator last);	// 把另一个链表指定的区间连接到当前链表。
13）splice(iterator pos, const list & l, iterator first);	// 把另一个链表从first开始的结点连接到当前链表。
14）void remove(const T& value);	 // 删除链表中所有值等于value的元素。
15）void remove_if(_Pr1 _Pred);    // 删除链表中满足条件的元素，参数_Pred是一元函数。
16）void unique();                 // 删除链表中相邻的重复元素，只保留一个。
17）void pop_front();              // 从链表头部删除一个元素。

• eg：

#include 
#include 
#include 
using  namespace std;int main()
{list  la = { 8,2,6,4,5 };for (auto& val : la) 	cout << val << " ";cout << endl;list  lb = { 3,7,9,10,1 };for (auto& val : lb) 	cout << val << " ";cout << endl;auto first = lb.begin();first++;auto last = lb.end();last--;la.splice(la.begin(), lb, first, last);for (auto& val : la) 	cout << val << " ";cout << endl;cout << "lb.size()=" << lb.size() << endl;for (auto& val : lb) 	cout << val << " ";cout << endl;
}

四、pair键值对

pair是类模板，一般用于表示key/value数据，其实现是结构体。

• pair结构模板的定义如下：

template 
struct pair 
{ T1 first;     // 第一个成员，一般表示key。T2 second;  // 第二个成员，一般表示value。pair();       // 默认构造函数。pair(const T1 &val1,const T2 &val2);   // 有两个参数的构造函数。pair(const pair &p);           // 拷贝构造函数。void swap(pair &p);           // 交换两个pair。
};

make_pair函数模板的定义如下：

template 
make_pair(const T1 &first,const T2 &second)
{return pair(first, second);
}

• eg：

#include 
using  namespace std;template 
struct Pair
{T1 first;        // 第一个成员，一般表示key。T2 second;  // 第二个成员，一般表示value。Pair()  {cout << "调用了有默认的构造函数。\n";}Pair(const T1& val1, const T2& val2) :first(val1), second(val2)  {cout << "调用了有两个参数的构造函数。\n";}Pair(const Pair& p) : first(p.first),second(p.second)  {cout << "调用了拷贝构造函数。\n";}
};template 
Pair make_Pair(const T1& first, const T2& second)
{//下面两种写法，Linux平台都不会多调用一次拷贝，都是RVO优化，直接移动// Pair p(first, second);// return p;        // 返回局部对象。return Pair(first, second);  // 返回临时对象。
}int main()
{//pair p0;//cout << "p0 first=" << p0.first << ",second=" << p0.second << endl;//pair p1(1, "西施1");    // 两个参数的构造函数。//cout << "p1 first=" << p1.first << ",second=" << p1.second << endl;//pair p2 = p1;             // 隐式构造。//cout << "p2 first=" << p2.first << ",second=" << p2.second << endl;//pair p3 = { 3, "西施3" };   //隐式构造。 pair p3 { 3, "西施3" };   // 两个参数的构造函数，省略了等于号。//cout << "p3 first=" << p3.first << ",second=" << p3.second << endl;auto p4 = Pair(4, "西施4");   // 匿名对象（隐式构造）。cout << "p4 first=" << p4.first << ",second=" << p4.second << endl;auto p5 = make_Pair(5, "西施5");   // make_pair()返回的临时对象。（隐式构造）cout << "p5 first=" << p5.first << ",second=" << p5.second << endl;//pair p6 = make_pair(6, "西施6");  //隐式构造， 让make_pair()函数自动推导，再调用拷贝构造，再隐式转换。//cout << "p6 first=" << p6.first << ",second=" << p6.second << endl;//auto p7 = make_pair(7, "西施7");    // 隐式构造，让make_pair()函数自动推导。//cout << "p7 first=" << p7.first << ",second=" << p7.second << endl;//p5.swap(p4);   // 交换两个pair。//cout << "p4 first=" << p4.first << ",second=" << p4.second << endl;//cout << "p5 first=" << p5.first << ",second=" << p5.second << endl;//struct st_girl//{//	string name;//	int   age;//	double height;//}; 用pair存放结构体数据。//pair p = { 3,{"西施",23,48.6} };//cout << "p first=" << p.first << endl;//cout << "p second.name=" << p.second.name << endl;//cout << "p second.age=" << p.second.age << endl;//cout << "p second.height=" << p.second.height << endl;
}

五、map容器

1.红黑树（平衡二叉排序树）

红黑树：左边节点比自己小，右边的节点比自己大

• 红黑树查找元素的方法，又称之为二分查找

• eg：跟节点比左子树的任意一个节点都大，比右子树的任意一个节点都小

• h：高度
  
  

• 物理结构：二叉链表

struct BTNode{pair p;//键值对BTNode* parent;//父节点BTNOde* lchirld;//左子树BTNode* * rchild;//右子树
};

2.构造函数

1）map();  // 创建一个空的map容器。
2）map(initializer_list> il); // 使用统一初始化列表。
3）map(const map& m);  // 拷贝构造函数。
4）map(Iterator first, Iterator last);  // 用迭代器创建map容器。
5）map(map&& m);  // 移动构造函数（C++11标准）。

• eg：

#include 
#include 

3.特性操作

size_t size() const;        // 返回容器的实际大小（已使用的空间）。
bool empty() const;      // 判断容器是否为空。
void clear();             // 清空容器。

4.元素操作

V &operator[](K key);             // 用给定的key访问元素。
const V &operator[](K key) const;  // 用给定的key访问元素，只读。
V &at(K key);                     // 用给定的key访问元素。
const V &at(K key) const;         // 用给定的key访问元素，只读。

注意：
1）[ ]运算符：如果指定键不存在，会向容器中添加新的键值对；如果指定键存在，则读取或修改容器中指定键的值。
2）at()成员函数：如果指定键不存在，不会向容器中添加新的键值对，而是直接抛出out_of_range 异常。

• eg：

#include 
#include 

5.赋值操作

给已存在的容器赋值，将覆盖容器中原有的内容。

1）map &operator=(const map& m);         // 把容器m赋值给当前容器。
2）map &operator=(initializer_list> il);  // 用统一初始化列表给当前容器赋值。

6.交换操作

交换的是树的根结点。

void swap(map& m);    // 把当前容器与m交换。

7.比较操作

bool operator == (const map& m) const;
bool operator != (const map& m) const;

8.查找操作

1）查找键值为key的键值对
在map容器中查找键值为key的键值对，如果成功找到，则返回指向该键值对的迭代器；失败返回end()。

iterator find(const K &key); 
const_iterator find(const K &key) const;  // 只读。

2）查找键值>=key的键值对
在map容器中查找第一个键值>=key的键值对，成功返回迭代器；失败返回end()。

iterator lower_bound(const K &key); 
const_iterator lower_bound(const K &key) const;  // 只读。

3）查找键>key的键值对
在map容器中查找第一个键值>key的键值对，成功返回迭代器；失败返回end()。

iterator upper_bound(const K &key); 
const_iterator upper_bound(const K &key) const;  // 只读。

4）统计键值对的个数
统计map容器中键值为key的键值对的个数。

size_t count(const K &key) const;

• eg：

#include 
#include 

9.插入和删除

1）void insert(initializer_list> il);  // 用统一初始化列表在容器中插入多个元素。
2）pair insert(const pair &value);  // 在容器中插入一个元素，返回值pair：first是已插入元素的迭代器，second是插入结果。
3）void insert(iterator first,iterator last);  // 用迭代器插入一个区间的元素。
4）pair emplace (...);  // 将创建新键值对所需的数据作为参数直接传入，map容器将直接构造元素。返回值pair：first是已插入元素的迭代器，second是插入结果。
例：mm.emplace(piecewise_construct, forward_as_tuple(8), forward_as_tuple("冰冰", 18));
5）iterator emplace_hint (const_iterator pos,...); // 功能与第4）个函数相同，第一个参数提示插入位置，该参数只有参考意义，如果提示的位置是正确的，对性能有提升，如果提示的位置不正确，性能反而略有下降，但是，插入是否成功与该参数元关。该参数常用end()和begin()。成功返回新插入元素的迭代器；如果元素已经存在，则插入失败，返回现有元素的迭代器。
6）size_t erase(const K & key);  // 从容器中删除指定key的元素，返回已删除元素的个数。
7）iterator erase(iterator pos);  // 用迭代器删除元素，返回下一个有效的迭代器。
8）iterator erase(iterator first,iterator last);  // 用迭代器删除一个区间的元素，返回下一个有效的迭代器。

• eg：

#include 
#include 

六、unordered_map容器

1.哈希表

哈希表长（桶的个数）：数组的长度；
哈希函数：

size_t hash(const T& key){...//key%小于哈希表长的最大质数
}

装填因子：元素总数/表长，其值越大，效率越低

unordered_map容器封装了哈希表，查找、插入和删除元素时，只需要比较几次key的值。

包含头文件： #include
unordered_map容器的元素是pair键值对。
unordered_map类模板的声明：
template , class _Keyeq = equal_to,class _Alloc = allocator>>
class unordered_map : public _Hash<_Umap_traits, _Alloc, false>>
{…
}创建std::unordered_map类模板的别名：
template
using umap = std::unordered_map;

第一个模板参数K：key的数据类型（pair.first）。
第二个模板参数V：value的数据类型（pair.second）。
第三个模板参数_Hasher：哈希函数，默认值为std::hash
第四个模板参数_Keyeq：比较函数，用于判断两个key是否相等，默认值是std::equal_to。
第五个模板参数_Alloc：分配器，缺省用new和delete。

2.构造函数

1）umap();  // 创建一个空的umap容器。
2）umap(size_t bucket);  // 创建一个空的umap容器，指定了桶的个数，下同。
3）umap(initializer_list> il); // 使用统一初始化列表。
4）umap(initializer_list> il, size_t bucket); // 使用统一初始化列表。
5）umap(Iterator first, Iterator last);  // 用迭代器创建umap容器。
6）umap(Iterator first, Iterator last, size_t bucket);  // 用迭代器创建umap容器。
7）umap(const umap& m);  // 拷贝构造函数。
8）umap(umap&& m);  // 移动构造函数（C++11标准）。

• eg：

#include 
#include 
using  namespace std;template
using umap = std::unordered_map;   int main()
{// 1）umap();  // 创建一个空的map容器。umap m1;// 2）umap(initializer_list> il); // 使用统一初始化列表。umap m2({ { 8,"冰冰" }, { 3,"西施" }, { 1,"幂幂" }, { 7,"金莲" }, { 5,"西瓜" } });// umap m2={ { 8,"冰冰" }, { 3,"西施" }, { 1,"幂幂" }, { 7,"金莲" }, { 5,"西瓜" } };// umap m2   { { 8,"冰冰" }, { 3,"西施" }, { 1,"幂幂" }, { 7,"金莲" }, { 5,"西瓜" } };for (auto& val : m2)cout << val.first << "," << val.second << "  ";cout << endl;// 3）umap(const map&m);  // 拷贝构造函数。umap m3 = m2;for (auto& val : m3)cout << val.first << "," << val.second << "  ";cout << endl;// 4）umap(Iterator first, Iterator last);  // 用迭代器创建map容器。auto first = m3.begin();  first++;auto last = m3.end();  last--;umap m4(first, last);for (auto& val : m4)cout << val.first << "," << val.second << "  ";cout << endl;// 5）umap(map && m);  // 移动构造函数（C++11标准）。
}

3.特性操作

1）size_t size() const;        // 返回容器中元素的个数。
2）bool empty() const;      // 判断容器是否为空。
3）void clear();             // 清空容器。
4）size_t max_bucket_count();     // 返回容器底层最多可以使用多少桶，无意义。
5）size_t bucket_count();          // 返回容器桶的数量，空容器有8个桶。
6）float load_factor();   // 返回容器当前的装填因子，load_factor() = size() / bucket_count()。
7）float max_load_factor();        // 返回容器的最大装填因子，达到该值后，容器将扩充，缺省为1。
8）void max_load_factor (float z ); // 设置容器的最大装填因子。
9）iterator begin(size_t n);        // 返回第n个桶中第一个元素的迭代器。
10）iterator end(size_t n);          // 返回第n个桶中最后一个元素尾后的迭代器。
11）void reserve(size_t n);          // 将容器设置为至少n个桶。
12）void rehash(size_t n);           // 将桶的数量调整为>=n。如果n大于当前容器的桶数，该方法会将容器重新哈希；如果n的值小于当前容器的桶数，该方法可能没有任何作用。
13）size_t bucket_size(size_t n);     // 返回第n个桶中元素的个数，0 <= n < bucket_count()。
14）size_t bucket(K &key);          // 返回值为key的元素对应的桶的编号。

4.元素操作

V &operator[](K key);             // 用给定的key访问元素。
const V &operator[](K key) const;  // 用给定的key访问元素，只读。
V &at(K key);                     // 用给定的key访问元素。
const V &at(K key) const;         // 用给定的key访问元素，只读。

注意：

• 1）[ ]运算符：如果指定键不存在，会向容器中添加新的键值对；如果指定键存在，则读取或修改容器中指定键的值。

• 2）at()成员函数：如果指定键不存在，不会向容器中添加新的键值对，而是直接抛出out_of_range 异常。

• eg：

#include 
#include 
using  namespace std;template
using umap = std::unordered_map;  int main()
{umap m( { { "08","冰冰" }, { "03","西施" }, { "01","幂幂" }, { "07","金莲" }, { "05","西瓜" } } );cout << "m[08]=" << m["08"] << endl;     // 显示key为08的元素的value。cout << "m[09]=" << m["09"] << endl;    // 显示key为09的元素的value。key为09的元素不存在，将添加新的键值对。m["07"] = "花花";                                          // 把key为07的元素的value修改为花花。m["12"] = "小乔";                                          // 将添加新的键值对。for (auto& val : m)cout << val.first << "," << val.second << "  ";cout << endl;
}

5.赋值操作

给已存在的容器赋值，将覆盖容器中原有的内容。

1）umap &operator=(const umap& m);       // 把容器m赋值给当前容器。
2）umap &operator=(initializer_list> il);  // 用统一初始化列表给容器赋值。

6.交换操作

交换的是树的根结点。

void swap(umap& m);    // 把当前容器与m交换。

7.比较操作

bool operator == (const umap& m) const;
bool operator != (const umap& m) const;

8.查找操作

1）查找键值为key的键值对

• 在umap容器中查找键值为key的键值对，如果成功找到，则返回指向该键值对的迭代器；失败返回end()。

iterator find(const K &key); 
const_iterator find(const K &key) const;  // 只读。

2）统计键值对的个数

• 统计umap容器中键值为key的键值对的个数。

size_t count(const K &key) const;

9.插入和删除

1）void insert(initializer_list> il);  // 用统一初始化列表在容器中插入多个元素。
2）pair insert(const pair &value);  // 在容器中插入一个元素，返回值pair：first是已插入元素的迭代器，second是插入结果。
3）void insert(iterator first,iterator last);  // 用迭代器插入一个区间的元素。
4）pair emplace (...);  // 将创建新键值对所需的数据作为参数直接传入，map容器将直接构造元素。返回值pair：first是已插入元素的迭代器，second是插入结果。
例：mm.emplace(piecewise_construct, forward_as_tuple(8), forward_as_tuple("冰冰", 18));
5）iterator emplace_hint (const_iterator pos,...); // 功能与第4）个函数相同，第一个参数提示插入位置，该参数只有参考意义。对哈希容器来说，此函数意义不大。
6）size_t erase(const K & key);  // 从容器中删除指定key的元素，返回已删除元素的个数。
7）iterator erase(iterator pos);  // 用迭代器删除元素，返回下一个有效的迭代器。
8）iterator erase(iterator first,iterator last);  // 用迭代器删除一个区间的元素，返回下一个有效的迭代器。

• eg：

#include 
#include 
using  namespace std;template
using umap = std::unordered_map;class CGirl        // 超女类。
{
public:string m_name;   // 超女姓名。int      m_age;       // 超女年龄。/*CGirl() : m_age(0) {cout << "默认构造函数。\n";}*/CGirl(const string name, const int age) : m_name(name), m_age(age) {cout << "两个参数的构造函数。\n";}CGirl(const CGirl& g) : m_name(g.m_name), m_age(g.m_age) {cout << "拷贝构造函数。\n";}
};int main()
{//umap mm;mm.insert     (pair(8, CGirl("冰冰", 18)));                // 一次构造函数，两次拷贝构造函数。mm.insert     (make_pair(8, CGirl("冰冰", 18)));     // 一次构造函数，两次拷贝构造函数。mm.emplace(pair(8, CGirl("冰冰", 18)));                // 一次构造函数，两次拷贝构造函数。mm.emplace(make_pair(8, CGirl("冰冰", 18)));     // 一次构造函数，两次拷贝构造函数。mm.emplace(8, CGirl("冰冰", 18));                                             // 一次构造函数，一次拷贝构造函数。// mm.emplace(8, "冰冰", 18);                                                        // 错误。//mm.emplace(piecewise_construct, forward_as_tuple(8), forward_as_tuple("冰冰", 18));  // 一次构造函数。//for (const auto& val : mm)//	cout << val.first << "," << val.second.m_name << "," << val.second.m_name << "  ";//cout << endl;//return 0;umap m;// 1）void insert(initializer_list> il);  // 用统一初始化列表在容器中插入多个元素。m.insert({ { 8,"冰冰" }, { 3,"西施" } });m.insert({ pair(1,"幂幂"), make_pair(7,"金莲"), {5,"西瓜"} });m.insert({ { 18,"冰冰" }, { 3,"西施" } });// 2）pair insert(const pair &value);  // 在容器中插入一个元素，返回值pair：first是已插入元素的迭代器，second是插入结果。auto ret = m.insert(pair(18, "花花"));if (ret.second == true) cout << "插入成功：" << ret.first->first << "," << ret.first->second << endl;else cout << "插入失败。\n";// 3）void insert(iterator first, iterator last);  // 用迭代器插入一个区间的元素。// 4）pair emplace(...);  // 将创建新键值对所需的数据作为参数直接传入，umap容器将直接构造元素。// 返回值pair：first是已插入元素的迭代器，second是插入结果。auto ret1 = m.emplace(20, "花花");if (ret1.second == true) cout << "插入成功：" << ret1.first->first << "," << ret1.first->second << endl;else cout << "插入失败。\n";// 5）iterator emplace_hint(const_iterator pos, ...); m.emplace_hint(m.begin(), piecewise_construct, forward_as_tuple(23), forward_as_tuple("冰棒"));for (auto& val : m)cout << val.first << "," << val.second << "  ";cout << endl;
}

六、queue容器

queue容器的逻辑结构是队列，物理结构可以是数组或链表，主要用于多线程之间的数据共享。

包含头文件： #include
queue类模板的声明：
template >
class queue{……
}

第一个模板参数T：元素的数据类型。
第二个模板参数_Container：底层容器的类型，缺省是std::deque，可以用std::list，还可以用自定义的类模板。

• queue容器不支持迭代器。

1.构造函数

1）queue();  // 创建一个空的队列。
2）queue(const queue& q);  // 拷贝构造函数。
3）queue(queue&& q);  // 移动构造函数（C++11标准）。
析构函数~queue()释放内存空间。

2.常用操作

1）void push(const T& value);  // 元素入队。
2）void emplace(…);           // 元素入队，…用于构造元素。C++11
3）size_t size() const;          // 返回队列中元素的个数。
4）bool empty() const;        // 判断队列是否为空。
5）T &front();                 // 返回队头元素。
6）const T &front();           // 返回队头元素，只读。
7）T &back();                 // 返回队尾元素。
8）const T &back();           // 返回队头元素，只读。
9）void pop();                // 出队，删除队头的元素。

• eg：

#include 
#include 
#include 
#include 
using  namespace std;class girl       // 超女类。
{
public:int m_bh;             // 编号。string m_name;  // 姓名。girl(const int& bh, const string& name) : m_bh(bh), m_name(name) {}
};int main()
{// template >// class queue {//	 ……// }// 第一个模板参数T：元素的数据类型。// 第二个模板参数_Container：底层容器的类型，缺省是std::deque，可以用std::list，还可以用自定义的类模板。queue> q;          // 物理结构为链表。//queue> q;    // 物理结构为数组。//queue q;                           // 物理结构为数组。//queue> q;    // 物理结构为vector，不可以。	q.push(girl(3, "西施"));   // 效率不高。q.emplace(8, "冰冰");     // 效率更高。q.push(girl(5, "幂幂"));q.push(girl(2, "西瓜"));while (q.empty() == false){cout << "编号：" << q.front().m_bh << "，姓名：" << q.front().m_name << endl;q.pop();}
}

3.其他操作

1）queue &operator=(const queue &q);    // 赋值。
2）void swap(queue &q);    // 交换。
3）bool operator == (const queue & q) const; // 重载==操作符。
4）bool operator != (const queue & q) const; // 重载!=操作符。

七、STL其他容器

1.array（静态数组）

1）物理结构

• 在栈上分配内存（其余STL都是堆上的容器），创建数组的时候，数组长度必须是常量，创建后的数组大小不可变。

template
class array{
private:T elems_[size]; ……
};

2）迭代器

• 随机访问迭代器。

3）特点

• 部分场景中，比常规数组更方便（能用于模板），可以代替常规数组。

4）各种操作

1）void fill(const T & val);     // 给数组填充值（清零）。
2）size_t size();               // 返回数组的大小。
3）bool empty() const;        // 无意义。
4）T &operator[](size_t n); 
5）const T &operator[](size_t n) const;  // 只读。
6）T &at(size_t n); 
7）const T &at(size_t n) const;          // 只读。
8）T *data();            // 返回数组的首地址。
9）const T *data() const; // 返回数组的首地址。
10）T &front();          // 第一个元素。
11）const T &front();    // 第一个元素，只读。
12）const T &back();    // 最后一个元素，只读。
13）T &back();        // 最后一个元素。

• ref：从0基础系统化学习C++，不可能学不会，https://gitee.com/jiwangreal/code_bbs_code