第9章 顺序容器
顺序容器概述(Overview of the Sequential Containers)
顺序容器类型:
类型 | 特性 |
---|---|
vector | 可变大小数组。支持快速随机访问。在尾部之外的位置插入/删除元素可能很慢 |
deque | 双端队列。支持快速随机访问。在头尾位置插入/删除速度很快 |
list | 双向链表。只支持双向顺序访问。在任何位置插入/删除速度都很快 |
forward_list | 单向链表。只支持单向顺序访问。在任何位置插入/删除速度都很快 |
array | 固定大小数组。支持快速随机访问。不能添加/删除元素 |
string | 类似vector ,但用于保存字符。支持快速随机访问。在尾部插入/删除速度很快 |
forward_list
和array
是C++11新增类型。与内置数组相比,array
更安全易用。forward_list
没有size
操作。
容器选择原则:
- 除非有合适的理由选择其他容器,否则应该使用
vector
。 - 如果程序有很多小的元素,且空间的额外开销很重要,则不要使用
list
或forward_list
。 - 如果程序要求随机访问容器元素,则应该使用
vector
或deque
。 - 如果程序需要在容器头尾位置插入/删除元素,但不会在中间位置操作,则应该使用
deque
。 - 如果程序只有在读取输入时才需要在容器中间位置插入元素,之后需要随机访问元素。则:
- 先确定是否真的需要在容器中间位置插入元素。当处理输入数据时,可以先向
vector
追加数据,再调用标准库的sort
函数重排元素,从而避免在中间位置添加元素。 - 如果必须在中间位置插入元素,可以在输入阶段使用
list
。输入完成后将list
中的内容拷贝到vector
中。
- 先确定是否真的需要在容器中间位置插入元素。当处理输入数据时,可以先向
- 不确定应该使用哪种容器时,可以先只使用
vector
和list
的公共操作:使用迭代器,不使用下标操作,避免随机访问。这样在必要时选择vector
或list
都很方便。
容器库概览(Container Library Overview)
每个容器都定义在一个头文件中,文件名与类型名相同。容器均为模板类型。
迭代器(Iterators)
forward_list
类型不支持递减运算符--
。
一个迭代器范围(iterator range)由一对迭代器表示。这两个迭代器通常被称为begin
和end
,分别指向同一个容器中的元素或尾后地址。end
迭代器不会指向范围中的最后一个元素,而是指向尾元素之后的位置。这种元素范围被称为左闭合区间(left-inclusive interval),其标准数学描述为[begin,end)
。迭代器begin
和end
必须指向相同的容器,end
可以与begin
指向相同的位置,但不能指向begin
之前的位置(由程序员确保)。
假定begin
和end
构成一个合法的迭代器范围,则:
- 如果
begin
等于end
,则范围为空。 - 如果
begin
不等于end
,则范围内至少包含一个元素,且begin
指向该范围内的第一个元素。 - 可以递增
begin
若干次,令begin
等于end
。
while (begin != end) { *begin = val; // ok: range isn't empty so begin denotes an element ++begin; // advance the iterator to get the next element }
容器类型成员(Container Type Members)
通过类型别名,可以在不了解容器元素类型的情况下使用元素。如果需要元素类型,可以使用容器的value_type
。如果需要元素类型的引用,可以使用reference
或const_reference
。
begin和end成员(begin and end Members)
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
当auto
与begin
或end
结合使用时,返回的迭代器类型依赖于容器类型。但调用以c
开头的版本仍然可以获得const
迭代器,与容器是否是常量无关。
当程序不需要写操作时,应该使用cbegin
和cend
。
容器定义和初始化(Defining and Initializing a Container)
容器定义和初始化方式:
将一个容器初始化为另一个容器的拷贝时,两个容器的容器类型和元素类型都必须相同。
传递迭代器参数来拷贝一个范围时,不要求容器类型相同,而且新容器和原容器中的元素类型也可以不同,但是要能进行类型转换。
// each container has three elements, initialized from the given initializers list<string> authors = {"Milton", "Shakespeare", "Austen"}; vector<const char*> articles = {"a", "an", "the"}; list<string> list2(authors); // ok: types match deque<string> authList(authors); // error: container types don't match vector<string> words(articles); // error: element types must match // ok: converts const char* elements to string forward_list<string> words(articles.begin(), articles.end());
C++11允许对容器进行列表初始化。
// each container has three elements, initialized from the given initializers list<string> authors = {"Milton", "Shakespeare", "Austen"}; vector<const char*> articles = {"a", "an", "the"};
定义和使用array
类型时,需要同时指定元素类型和容器大小。
array<int, 42> // type is: array that holds 42 ints array<string, 10> // type is: array that holds 10 strings array<int, 10>::size_type i; // array type includes element type and size array<int>::size_type j; // error: array<int> is not a type
对array
进行列表初始化时,初始值的数量不能大于array
的大小。如果初始值的数量小于array
的大小,则只初始化靠前的元素,剩余元素会被值初始化。如果元素类型是类类型,则该类需要一个默认构造函数。
可以对array
进行拷贝或赋值操作,但要求二者的元素类型和大小都相同。
赋值和swap(Assignment and swap)
容器赋值操作:
赋值运算符两侧的运算对象必须类型相同。assign
允许用不同但相容的类型赋值,或者用容器的子序列赋值。
list<string> names; vector<const char*> oldstyle; names = oldstyle; // error: container types don't match // ok: can convert from const char*to string names.assign(oldstyle.cbegin(), oldstyle.cend());
由于其旧元素被替换,因此传递给assign
的迭代器不能指向调用assign
的容器本身。
swap
交换两个相同类型容器的内容。除array
外,swap
不对任何元素进行拷贝、删除或插入操作,只交换两个容器的内部数据结构,因此可以保证快速完成。
vector<string> svec1(10); // vector with ten elements vector<string> svec2(24); // vector with 24 elements swap(svec1, svec2);
赋值相关运算会导致指向左边容器内部的迭代器、引用和指针失效。而swap
操作交换容器内容,不会导致迭代器、引用和指针失效(array
和string
除外)。
对于array
,swap
会真正交换它们的元素。因此在swap
操作后,指针、引用和迭代器所绑定的元素不变,但元素值已经被交换。
array<int, 3> a = { 1, 2, 3 }; array<int, 3> b = { 4, 5, 6 }; auto p = a.cbegin(), q = a.cend(); a.swap(b); // 输出交换后的值,即4、5、6 while (p != q) { cout << *p << endl; ++p; }
对于其他容器类型(除string
),指针、引用和迭代器在swap
操作后仍指向操作前的元素,但这些元素已经属于不同的容器了。
vector<int> a = { 1, 2, 3 }; vector<int> b = { 4, 5, 6 }; auto p = a.cbegin(), q = a.cend(); a.swap(b); // 输出交换前的值,即1、2、3 while (p != q) { cout << *p << endl; ++p; }
array
不支持assign
,也不允许用花括号列表进行赋值。
array<int, 10> a1 = {0,1,2,3,4,5,6,7,8,9}; array<int, 10> a2 = {0}; // elements all have value 0 a1 = a2; // replaces elements in a1 a2 = {0}; // error: cannot assign to an array from a braced list
新标准库同时提供了成员和非成员函数版本的swap
。非成员版本的swap
在泛型编程中非常重要,建议统一使用非成员版本的swap
。
容器大小操作(Container Size Operations)
size
成员返回容器中元素的数量;empty
当size
为0时返回true
,否则返回false
;max_size
返回一个大于或等于该类型容器所能容纳的最大元素数量的值。forward_list
支持max_size
和empty
,但不支持size
。
关系运算符(Relational Operators)
每个容器类型都支持相等运算符(==
、!=
)。除无序关联容器外,其他容器都支持关系运算符(>
、>=
、<
、<=
)。关系运算符两侧的容器类型和保存元素类型都必须相同。
两个容器的比较实际上是元素的逐对比较,其工作方式与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 and v2 differ at element [2]: v1[2] is less than v2[2] v1 < v3 // false; all elements are equal, but v3 has fewer of them; v1 == v4 // true; each element is equal and v1 and v4 have the same size() v1 == v2 // false; v2 has fewer elements than v1
容器的相等运算符实际上是使用元素的==
运算符实现的,而其他关系运算符则是使用元素的<
运算符。如果元素类型不支持所需运算符,则保存该元素的容器就不能使用相应的关系运算。
顺序容器操作(Sequential Container Operations)
向顺序容器添加元素(Adding Elements to a Sequential Container)
除array
外,所有标准库容器都提供灵活的内存管理,在运行时可以动态添加或删除元素。
push_back
将一个元素追加到容器尾部,push_front
将元素插入容器头部。
// read from standard input, putting each word onto the end of container string word; while (cin >> word) container.push_back(word);
insert
将元素插入到迭代器指定的位置之前。一些不支持push_front
的容器可以使用insert
将元素插入开始位置。
vector<string> svec; list<string> slist; // equivalent to calling slist.push_front("Hello!"); slist.insert(slist.begin(), "Hello!"); // no push_front on vector but we can insert before begin() // warning: inserting anywhere but at the end of a vector might be slow 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); // same as calling push_front
新标准库增加了三个直接构造而不是拷贝元素的操作:emplace_front
、emplace_back
和emplace
,其分别对应push_front
、push_back
和insert
。当调用push
或insert
时,元素对象被拷贝到容器中。而调用emplace
时,则是将参数传递给元素类型的构造函数,直接在容器的内存空间中构造元素。
// construct a Sales_data object at the end of c // uses the three-argument Sales_data constructor c.emplace_back("978-0590353403", 25, 15.99); // error: there is no version of push_back that takes three arguments c.push_back("978-0590353403", 25, 15.99); // ok: we create a temporary Sales_data object to pass to 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
。
访问元素(Accessing Elements)
每个顺序容器都有一个front
成员函数,而除了forward_list
之外的顺序容器还有一个back
成员函数。这两个操作分别返回首元素和尾元素的引用。
在调用front
和back
之前,要确保容器非空。
顺序容器的元素访问操作:
在容器中访问元素的成员函数都返回引用类型。如果容器是const
对象,则返回const
引用,否则返回普通引用。
可以快速随机访问的容器(string
、vector
、deque
和array
)都提供下标运算符。保证下标有效是程序员的责任。如果希望确保下标合法,可以使用at
成员函数。at
类似下标运算,但如果下标越界,at
会抛出out_of_range
异常。
vector<string> svec; // empty vector cout << svec[0]; // run-time error: there are no elements in svec! cout << svec.at(0); // throws an out_of_range exception
删除元素(Erasing Elements)
顺序容器的元素删除操作: