《C++ Primer》学习笔记（九）：顺序容器

专栏C++学习笔记

《C++ Primer》学习笔记/习题答案 总目录

• https://blog.youkuaiyun.com/TeFuirnever/article/details/100700212

——————————————————————————————————————————————————————

• 《C++ Primer》习题参考答案：第9章 - 顺序容器
• 《C++ Primer》学习笔记（三）：字符串、向量和数组
• 《C++ Primer》习题参考答案：第3章 - 字符串、向量和数组

📚💻 Cpp-Prime5 + Cpp-Primer-Plus6 源代码和课后题

顺序容器

1、顺序容器概述

一个容器就是一些特定类型对象的集合。顺序容器（sequential container） 为程序员提供了控制元素存储和访问顺序的能力。这种顺序不依赖于元素的值，而是与元素加入容器时的位置相对应。

顺序容器类型：

除了固定大小的 array 外，其他容器都提供高效、灵活的内存管理。例如，

• string 和 vector 将元素保存在连续的内存空间中。由于元素是连续存储的，由元素的下标来计算其地址是非常快速的。但是，在这两种容器的中间位置添加或删除元素就会非常耗时：在一次插入或删除操作后，需要移动插入/删除位置之后的所有元素，来保持连续存储。而且添加一个元素有时可能还需要分配额外的存储空间。在这种情况下，每个元素都必须移动到新的存储空间中。
• list 和 forward_list 两个容器的设计目的是令容器任何位置的添加和删除操作都很快速。作为代价，这两个容器不支持元素的随机访问：为了访问一个元素，我们只能遍历整个容器。而且与 vector 、deque 和array 相比， 这两个容器的额外内存开销也很大。
• deque 是一个更为复杂的数据结构。与 string 和 vector 类似，deque 支持快速的随机访问。与 strìng 和 vector 一样，在 deque 的中间位置添加或删除元素的代价（可能）很高。但是，在 deque 的两端添加或删除元素都是很快的，与 list 或
  forward_list 添加删除元素的速度相当。

forward_list 和 array 是C++11新增类型。与内置数组相比，array 更安全易用。

array 对象的大小是固定的，forward_list 没有 size 操作。

新标准库容器的性能几乎肯定与最精心优化过的同类数据结构一样好（通常会更好）。现代C++程序应该使用标准库容器，而不是更原始的数据结构，如内置数组。

容器选择原则：

• 除非有合适的理由选择其他容器，否则应该使用 vector。
• 如果程序有很多小的元素，且空间的额外开销很重要，则不要使用 list 或 forward_list。
• 如果程序要求随机访问容器元素，则应该使用 vector 或 deque。
• 如果程序需要在容器头尾位置插入/删除元素，但不会在中间位置操作，则应该使用 deque。
• 如果程序只有在读取输入时才需要在容器中间位置插入元素，之后需要随机访问元素。则：
  • 先确定是否真的需要在容器中间位置插入元素。当处理输入数据时，可以先向 vector 追加数据，再调用标准库的 sort 函数重排元素，从而避免在中间位置添加元素。
  • 如果必须在中间位置插入元素，可以在输入阶段使用 list。输入完成后将 list 中的内容拷贝到 vector 中。
• 不确定应该使用哪种容器时，可以先只使用 vector 和 list 的公共操作：使用迭代器，不使用下标操作，避免随机访问。这样在必要时选择 vector 或 list 都很方便。

2、容器库概览

每个容器都定义在一个头文件中，文件名与类型名相同。容器均为模板类型。

1）迭代器

forward_list 类型不支持递减运算符 --。

一个 迭代器范围（iterator range） 由一对迭代器表示。这两个迭代器通常被称为 begin 和 end，分别指向同一个容器中的元素或尾后地址。end 迭代器不会指向范围中的最后一个元素，而是指向尾元素之后的位置。这种元素范围被称为 左闭合区间（left-inclusive interval），其标准数学描述为 [begin，end）。迭代器 begin 和 end 必须指向相同的容器，end 可以与 begin 指向相同的位置，但不能指向 begin 之前的位置（由程序员确保）。

如果满足如下条件，两个迭代器 begin 和 end 构成一个迭代器范：

• 它们指向同一个容器中的元素，或者是容器最后一个元素之后的位置， 且我们可以通过反复递增 begin 来到达 end。换句话说，end 不在 begin 之前。

假定 begin 和 end 构成一个合法的迭代器范围，则：

• 如果 begin 等于 end，则范围为空。
• 如果 begin 不等于 end，则范围内至少包含一个元素，且 begin 指向该范围内的第一个元素。
• 可以递增 begin 若干次，令 begin 等于 end。

while (begin != end)
{
    *begin = val;   // 正确：范围非空，因此begin指向一个元素
    ++begin;    	// 移动迭代器，获取下一个元素
}

2）容器类型成员

通过类型别名，可以在不了解容器元素类型的情况下使用元素。如果需要元素类型，可以使用容器的 value_type。如果需要元素类型的引用，可以使用 reference 或 const_reference。

3）begin和end成员

begin 和 end 操作生成指向容器中第一个元素和尾后地址的迭代器。其常见用途是形成一个包含容器中所有元素的迭代器范围。

begin 和 end 操作有多个版本：带 r 的版本返回反向迭代器。以 c 开头的版本（C++11新增）返回 const 迭代器。不以 c 开头的版本都是重载的，当对非常量对象调用这些成员时，返回普通迭代器，对 const 对象调用时，返回 const 迭代器。

list<string> a = {"Milton", "Shakespeare", "Austen"};
auto it1 = a.begin();    // list<string>::iterator
auto it2 = a.rbegin();   // list<string>::reverse_iterator
auto it3 = a.cbegin();   // list<string>::const_iterator
auto it4 = a.crbegin();  // list<string>::const_reverse_iterator

以 c 开头的版本是C++新标准引入的，用以支持 auto 与 begin 和 end 函数结合使用。

当 auto 与 begin 或 end 结合使用时，返回的迭代器类型依赖于容器类型。但调用以 c 开头的版本仍然可以获得 const 迭代器，与容器是否是常量无关。

当程序不需要访问时，应该使用 cbegin 和 cend。

4）容器定义和初始化

容器定义和初始化方式：

将一个新容器创建为另一个容器的拷贝的方法有两种: 可以直接拷贝整个容器，或者(array 除外)拷贝由一个迭代器对指定的元素范围。

将一个容器初始化为另一个容器的拷贝时，两个容器的容器类型和元素类型都必须相同。传递迭代器参数来拷贝一个范围时，不要求容器类型相同，而且新容器和原容器中的元素类型也可以不同，但是要能进行类型转换。

// 每个容器有三个元素，用给定的初始化器进行初始化
list<string> authors = {"Milton", "Shakespeare", "Austen"};
vector<const char*> articles = {"a", "an", "the"};
list<string> list2(authors);        // 正确：类型匹配
deque<string> authList(authors);    // 错误：容器类型不匹配
vector<string> words(articles);     // 错误：容器类型必须匹配
// 正确：可以将const char*元素转换为string
forward_list<string> words(articles.begin(), articles.end());

当将一个容器初始化为另一个容器的拷贝时，两个容器的容器类型和元余类型都必须相同。

C++11允许对容器进行列表初始化。

// 每个容器有三个元素，用给定的初始化器进行初始化
list<string> authors = {"Milton", "Shakespeare", "Austen"};
vector<const char*> articles = {"a", "an", "the"};

只有顺序容器的构造函数才接受大小参数，关联容器并不支持。

定义和使用 array 类型时，需要同时指定元素类型和容器大小。

array<int, 42>      // 类型为：保存42个int的数组
array<string, 10>   // 类型为：保存10个string的数组
array<int, 10>::size_type i;   // 数组类型包括元素类型和大小
array<int>::size_type j;       // 错误：array<int>不是一个类型

对 array 进行列表初始化时，初始值的数量不能大于 array 的大小。如果初始值的数量小于 array 的大小，则只初始化靠前的元素，剩余元素会被值初始化。如果元素类型是类类型，则该类需要一个默认构造函数。

可以对 array 进行拷贝或赋值操作，但要求二者的元素类型和大小都相同。

5）赋值和swap

容器赋值操作：

赋值运算符两侧的运算对象必须类型相同。assign 允许用不同但相容的类型赋值，或者用容器的子序列赋值。

list<string> names;
vector<const char*> oldstyle;
names = oldstyle;   // 错误: 容器类型不匹配
// 正确：可以将const char*转换为string
names.assign(oldstyle.cbegin(), oldstyle.cend());

由于其旧元素被替换，因此传递给 assign 的迭代器不能指向调用 assign 的容器本身。

swap 交换两个相同类型容器的内容。

除 array 外，swap 不对任何元素进行拷贝、删除或插入操作，只交换两个容器的内部数据结构，因此可以保证快速完成。

vector<string> svec1(10);   // 10个元素的vector
vector<string> svec2(24);   // 24个元素的vector
swap(svec1, svec2);

对于 array，swap 会真正交换它们的元素。因此在 swap 操作后，指针、引用和迭代器所绑定的元素不变，但元素值已经被交换。

对于其他容器类型（除 string），指针、引用和迭代器在 swap 操作后仍指向操作前的元素，但这些元素已经属于不同的容器了。

新标准库同时提供了成员和非成员函数版本的 swap。非成员版本的 swap 在泛型编程中非常重要，建议统一使用非成员版本的 swap。

6）容器大小操作

• size 成员返回容器中元素的数量；
• empty 当 size 为0时返回 true，否则返回 false；
• max_size 返回一个大于或等于该类型容器所能容纳的最大元素数量的值。

forward_list 支持 max_size 和 empty，但不支持 size。

7）关系运算符

每个容器类型都支持相等运算符（==、!=）。除无序关联容器外，其他容器都支持关系运算符（>、>=、<、<=）。关系运算符两侧的容器类型和保存元素类型都必须相同。

两个容器的比较实际上是元素的逐对比较，其工作方式与string的关系运算符类似：

• 如果两个容器大小相同且所有元素对应相等，则这两个容器相等。
• 如果两个容器大小不同，但较小容器中的每个元素都等于较大容器中的对应元素，则较小容器小于较大容器。
• 如果两个容器都不是对方的前缀子序列，则两个容器的比较结果取决于第一个不等元素的比较结果。

vector<int> v1 = { 1, 3, 5, 7, 9, 12 };
vector<int> v2 = { 1, 3, 9 };
vector<int> v3 = { 1, 3, 5, 7 };
vector<int> v4 = { 1, 3, 5, 7, 9, 12 };
v1 < v2     // true；v1和v2在元素[2]处不同：v1[2]小于等于v2[2]
v1 < v3     // false；所有元素都相等，但v3中元素数目更少
v1 == v4    // true；每个元素都相等，且v1和v4大小相同
v1 == v2    // false；v2元素数目比v1少

容器的相等运算符实际上是使用元素的 == 运算符实现的，而其他关系运算符则是使用元素的 < 运算符。如果元素类型不支持所需运算符，则保存该元素的容器就不能使用相应的关系运算。

3、顺序容器操作

1）向顺序容器添加元素

除 array 外，所有标准库容器都提供灵活的内存管理，在运行时可以动态添加或删除元素。

push_back 将一个元素追加到容器尾部，push_front 将元素插入容器头部。除 array 和 forward_list 之外， 每个顺序容器(包括 string 类型〉都支持 push_back。

// 从标准输入读取数据，将每个单词放到容器末尾
string word;
while (cin >> word)
    container.push_back(word);

insert 将元素插入到迭代器指定的位置之前。一些不支持 push_front 的容器可以使用 insert 将元素插入开始位置。

vector<string> svec;
list<string> slist;
// 等价于调用slist.push_front("Hello!");
slist.insert(slist.begin(), "Hello!");
// vector不支持push_front，但我们可以插入到begin()之前
// 警告：插入到vector末尾之外的任何位置都可能很慢
svec.insert(svec.begin(), "Hello!");

将元素插入到 vector、deque 或 string 的任何位置都是合法的，但可能会很耗时。

在新标准库中，接受元素个数或范围的 insert 版本返回指向第一个新增元素的迭代器，而旧版本中这些操作返回 void。如果范围为空，不插入任何元素，insert 会返回第一个参数。

list<string> 1st;
auto iter = 1st.begin();
while (cin >> word)
    iter = 1st.insert(iter, word);  // 等价于调用push_front

新标准库增加了三个直接构造而不是拷贝元素的操作：emplace_front、emplace_back 和 emplace，其分别对应 push_front、push_back 和 insert。当调用 push或insert 时，元素对象被拷贝到容器中。而调用 emplace 时，则是将参数传递给元素类型的构造函数，直接在容器的内存空间中构造元素。

// 在c的末尾构造一个Sales_data对象
// 使用三个参数的Sales_data构造函数
c.emplace_back("978-0590353403", 25, 15.99);
// 错误：没有接受三个参数的push_back版本
c.push_back("978-0590353403", 25, 15.99);
// 正确：创建一个临时的Sales_data对象传递给push_back
c.push_back(Sales_data("978-0590353403", 25, 15.99));

传递给 emplace 的参数必须与元素类型的构造函数相匹配。

forward_list 有特殊版本的 insert 和 emplace 操作，且不支持 push_back 和 emplace_back。vector 和 string不支持 push_front 和 emplace_front。

emplace 函数在容器中直接构造元素。传递给 emplace 函数的参数必须与元素类型的构造函数相匹配。

2）访问元素

每个顺序容器都有一个 front 成员函数，而除了 forward_list 之外的顺序容器还有一个 back 成员函数。这两个操作分别返回首元素和尾元素的引用。

• 迭代器 end 指向的是容器尾元素之后的(不存在的)元素。为了获取尾元素，必须首先递减此迭代器；
• 在调用front和back之前(或解引用 begin 和 end 返回的迭代器)之前，要确保容器非空。

顺序容器的元素访问操作：

在容器中访问元素的成员函数都返回引用类型。如果容器是 const 对象，则返回 const 引用，否则返回普通引用。

可以快速随机访问的容器（string、vector、deque 和 array）都提供下标运算符。保证下标有效是程序员的责任。

如果希望确保下标合法，可以使用 at 成员函数。at 类似下标运算，但如果下标越界，at 会抛出 out_of_range 异常。

vector<string> svec;  // 空vector
cout << svec[0];      // 运行时错误：svec中没有元素！
cout << svec.at(0);   // 抛出一个out_of_range异常

3）删除元素

顺序容器的元素删除操作：

删除元素的成员函数并不检查其参数。删除元素前，程序员必须确保目标元素存在。

pop_front 和 pop_back 函数分别删除首元素和尾元素。vector 和 string 类型不支持 pop_front，forward_list 类型不支持 pop_back。

while (!ilist.empty()){
	process(ilist.front()); // 对ilist的首元素进行一些处理
	ilist.pop_front(); 		// 完成处理后删除首元素
}

erase 函数删除指定位置的元素。可以删除由一个迭代器指定的单个元素，也可以删除由一对迭代器指定的范围内的所有元素。两种形式的 erase 都返回指向删除元素（最后一个）之后位置的迭代器。

// 删除两个迭代器表示的范围内的元素
// 返回指向最后一个被删元素之后位置的迭代器
elem1 = slist.erase(elem1, elem2);  // 调用后，elem1 == e1em2

clear 函数删除容器内的所有元素。

slist.clear(); 								// 删除容器中所有元素
slist.erase(slist.begin(), slist.end()); 	// 等价调用

4）特殊的forward_list操作

在 forward_list 中添加或删除元素的操作是通过改变给定元素之后的元素来完成的。

由于这些操作与其他容器上的操作的实现方式不同，forward_list 并未定义 insert、emplace 和 erase，而是定义了名为 insert_after、emplace_after和 erase after 的操作。

forward_list 的插入和删除操作：

5）改变容器大小

顺序容器的大小操作：

resize 函数接受一个可选的元素值参数，用来初始化添加到容器中的元素，否则新元素进行值初始化。如果容器保存的是类类型元素，且 resize 向容器添加新元素，则必须提供初始值，或元素类型提供默认构造函数。

6）容器操作可能使迭代器失效

向容器中添加或删除元素可能会使指向容器元素的指针、引用或迭代器失效。失效的指针、引用或迭代器不再表示任何元素，使用它们是一种严重的程序设计错误。

• 向容器中添加元素后：
  • 如果容器是 vector 或 string 类型，且存储空间被重新分配，则指向容器的迭代器、指针和引用都会失效。如果存储空间未重新分配，指向插入位置之前元素的迭代器、指针和引用仍然有效，但指向插入位置之后元素的迭代器、指针和引用都会失效。
  • 如果容器是 deque 类型，添加到除首尾之外的任何位置都会使迭代器、指针和引用失效。如果添加到首尾位置，则迭代器会失效，而指针和引用不会失效。
  • 如果容器是 list 或 forward_list 类型，指向容器的迭代器、指针和引用仍然有效。
• 从容器中删除元素后，指向被删除元素的迭代器、指针和引用失效：
  • 如果容器是 list 或 forward_list 类型，指向容器其他位置的迭代器、指针和引用仍然有效。
  • 如果容器是 deque 类型，删除除首尾之外的任何元素都会使迭代器、指针和引用失效。如果删除尾元素，则尾后迭代器失效，其他迭代器、指针和引用不受影响。如果删除首元素，这些也不会受影响。
  • 如果容器是 vector 或 string 类型，指向删除位置之前元素的迭代器、指针和引用仍然有效。但尾后迭代器总会失效。

使用失效的迭代器、指针或引用是严重的运行时错误。

建议：管理迭代器
当你使用迭代器（或指向容器元素的引用或指针）时，最小化要求迭代器必须保持有效的程序片段是一个好的方法。
由于向迭代器添加元素和从迭代器删除元素的代码可能会使选代器失效，因此必须保证每次改变容器的操作之后都正确地重新定位迭代器。这个建议对 vector、string 和 deque 尤为重要。

如果在一个循环中插入/删除 deque、string 或 vector 中的元素，不要缓存 end 返回的迭代器。

// 更安全的方法:在每个循环步添加/删除元素后都重新计算end
while (begin != v.end())
{
    // 做一些处理
    ++begin;    // 向前移动begin，因为我们想在此元素之后插入元素
    begin = v.insert(begin, 42);    // 插入新位
    ++begin;    // 向前移动begin，跳过我们刚刚加入的元素
}

4、vector对象是如何增长的

vector 和 string 的实现通常会分配比新空间需求更大的内存空间，容器预留这些空间作为备用，可用来保存更多新元素。

容器大小管理操作：

reserve 并不改变容器中元素的数量，它仅影响 vector 预先分配多大的内存空间。

capacity 函数返回容器在不扩充内存空间的情况下最多可以容纳的元素数量。reserve 函数告知容器应该准备保存多少元素，它并不改变容器中元素的数量，仅影响容器预先分配的内存空间大小。

只有当需要的内存空间超过当前容量时，reserve 才会真正改变容器容量，分配不小于需求大小的内存空间。当需求大小小于当前容量时，reserve 并不会退回内存空间。因此在调用 reserve 之后，capacity 会大于或等于传递给 reserve 的参数。

在C++11中可以使用 shrink_to_fit 函数来要求 deque、vector 和 string 退回不需要的内存空间（并不保证退回）。

每个 vector 实现都可以选择自己的内存分配策略。但是必须遵守的一条原则是：只有当迫不得已时才可以分配新的内存空间。

5、额外的string操作

1）构造string的其他方法

构造 string 的其他方法：

从另一个 string 对象拷贝字符构造 string 时，如果提供的拷贝开始位置（可选）大于给定 string 的大小，则构造函数会抛出 out_of_range 异常。

子字符串操作：

如果传递给 substr 函数的开始位置超过 string 的大小，则函数会抛出 out_of_range 异常。

2）改变string的其他方法

修改 string 的操作：


append 函数是在 string 末尾进行插入操作的简写形式。

string s("C++ Primer"), s2 = s;     // 将s和s2初始化为"C++ Primer"
s.insert(s.size(), " 4th Ed.");     // s == "C++ Primer 4th Ed."
s2.append(" 4th Ed.");     // 等价方法:将" 4th Ed."追加到s2; s == s2

replace 函数是调用 erase 和 insert 函数的简写形式。

// 将"4th"替换为"5th"的等价方法
s.erase(11, 3);         // s == "C++ Primer Ed."
s.insert(11, "5th");    // s == "C++ Primer 5th Ed."
// 从位置11开始，删除3个字符并插入"5th"
s2.replace(11, 3, "5th");   // 等价方法: s == s2

3）string搜索操作

string 的每个搜索操作都返回一个 string::size_type 值，表示匹配位置的下标。如果搜索失败，则返回一个名为 string::npos 的 static 成员。标准库将 npos 定义为 const string::size_type 类型，并初始化为-1。

不建议用 int 或其他带符号类型来保存 string 搜索函数的返回值。

string 搜索操作：

4）compare函数

string 类型提供了一组 compare 函数进行字符串比较操作，类似C标准库的 strcmp 函数。

compare 函数的几种参数形式：

5）数值转换

C++11增加了 string 和数值之间的转换函数：

进行数值转换时，string 参数的第一个非空白字符必须是符号（+ 或 -）或数字。它可以以 0x 或 0X 开头来表示十六进制数。对于转换目标是浮点值的函数，string 参数也可以以小数点开头，并可以包含 e 或 E 来表示指数部分。

如果给定的 string 不能转换为一个数值，则转换函数会抛出 invalid_argument 异常。如果转换得到的数值无法用任何类型表示，则抛出 out_of_range 异常。

6、容器适配器

标准库定义了 stack、queue 和 priority_queue 三种容器适配器。容器适配器可以改变已有容器的工作机制。

所有容器适配器都支持的操作和类型：

默认情况下，stack 和 queue 是基于 deque 实现的，priority_queue 是基于 vector 实现的。可以在创建适配器时将一个命名的顺序容器作为第二个类型参数，来重载默认容器类型。

// 在vector上实现的空栈
stack<string, vector<string>> str_stk;
// strstk2在vector上实现，初始化时保存svec的拷贝
stack<string, vector<string>> str_stk2(svec);

所有适配器都要求容器具有添加和删除元素的能力，因此适配器不能构造在 array 上。适配器还要求容器具有添加、删除和访问尾元素的能力，因此也不能用 forward_list 构造适配器。

栈适配器stack定义在头文件stack中，其支持的操作如下：

队列适配器queue和priority_queue定义在头文件queue中，其支持的操作如下：


queue 使用先进先出（first-in，first-out，FIFO）的存储和访问策略。进入队列的对象被放置到队尾，而离开队列的对象则从队首删除。

如果想要更多的资源，欢迎关注 @我是管小亮，文字强迫症MAX~

回复【福利】即可获取我为你准备的大礼，包括C++，编程四大件，NLP，深度学习等等的资料。

想看更多文（段）章（子），欢迎关注微信公众号「程序员管小亮」~

参考文章

• 《C++ Primer》