9.1-9.3读书笔记

9.1 顺序容器概述

对于下面的程序任务，vector、deque和list哪种容器最为适合？解释你的选择的理由。如果没有哪一种容器优于其他容器，也请解释理由。

(a) 读取固定数量的单词，将它们按字典序插入到容器中。我们将在下一章中看到，关联容器更适合这个问题。

(b) 读取未知数量的单词，总是将单词插入到末尾。删除操作在头部进行。

© 从一个文件读取未知数量的整数。将这些数排序，然后将它们打印到标准输出。

(a) list ，因为需要频繁的插入操作。

(b) deque ，总是在头尾进行插入、删除操作。

© vector ，不需要进行插入删除操作。

9.2 容器库概览

定义一个list对象，其元素类型是int的deque。

std::list<std::deque> l;

构成迭代器范围的迭代器有何限制？

两个迭代器 begin 和 end需满足以下条件：

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

编写函数，接受一对指向vector的迭代器和一个int值。在两个迭代器指定的范围中查找给定的值，返回一个布尔值来指出是否找到。

bool find(vector::const_iterator begin, vector::const_iterator end, int i)
{
while (begin++ != end)
{
if (*begin == i)
return true;
}
return false;
}

下面的程序有何错误？你应该如何修改它？

list lst1;
list::iterator iter1 = lst1.begin(),
iter2 = lst1.end();
while (iter1 < iter2) /* … */
修改成如下：

while (iter1 != iter2)

为了索引int 的 vector中的元素，应该使用什么类型？

vector::size_type

为了读取string 的list 中的元素，应该使用什么类型？如果写入list，又应该使用什么类型？

list::const_iterator // 读
list::iterator // 写

begin 和 cbegin 两个函数有什么不同？

begin 返回的是普通迭代器，cbegin 返回的是常量迭代器。

下面4个对象分别是什么类型？

vector v1;
const vector v2;
auto it1 = v1.begin(), it2 = v2.begin();
auto it3 = v1.cbegin(), it4 = v2.cbegin();
这里的代码在 VS2013 下是有错误的。

错误 1 error C3538: 在声明符列表中，“auto”必须始终推导为同一类型 因此代码要改为
auto it1 = v1.begin();
auto it2 = v2.begin(), it3 = v1.cbegin(), it4 = v2.cbegin();
it1 是 vector::iterator

it2，it3 和 it4 是 vector::const_iterator

对于接受一个容器创建其拷贝的构造函数，和接受两个迭代器创建拷贝的构造函数，解释它们的不同。

接受一个容器创建其拷贝的构造函数，必须容器类型和元素类型都相同。
接受两个迭代器创建拷贝的构造函数，只需要元素的类型能够相互转换，容器类型和元素类型可以不同。

如何从一个list初始化一个vector？从一个vector又该如何创建？编写代码验证你的答案。

list ilst(5, 4);
vector ivc(5, 5);

vector dvc(ilst.begin(), ilst.end());
vector dvc2(ivc.begin(), ivc.end());

编写程序，将一个list中的char * 指针元素赋值给一个vector中的string。

std::list<const char*> l{ "hello", "world" };
std::vector<std::string> v;
v.assign(l.cbegin(), l.cend());

编写程序，判定两个vector是否相等。

std::vector<int> vec1{ 1, 2, 3, 4, 5 };
std::vector<int> vec2{ 1, 2, 3, 4, 5 };
std::vector<int> vec3{ 1, 2, 3, 4 };

std::cout << (vec1 == vec2 ? "true" : "false") << std::endl;
std::cout << (vec1 == vec3 ? "true" : "false") << std::endl;

重写上一题的程序，比较一个list中的元素和一个vector中的元素。

std::list<int>      li{ 1, 2, 3, 4, 5 };
std::vector<int>    vec2{ 1, 2, 3, 4, 5 };
std::vector<int>    vec3{ 1, 2, 3, 4 };

std::cout << (std::vector<int>(li.begin(), li.end()) == vec2 ? "true" : "false") << std::endl;
std::cout << (std::vector<int>(li.begin(), li.end()) == vec3 ? "true" : "false") << std::endl;

假定c1 和 c2 是两个容器，下面的比较操作有何限制？

if (c1 < c2)

c1 和 c2 必须是相同类型的容器并且保存相同类型的元素
元素类型要支持关系运算符

9.3 顺序容器操作

假定iv是一个int的vector，下面的程序存在什么错误？你将如何修改？

vector::iterator iter = iv.begin(),
mid = iv.begin() + iv.size() / 2;
while (iter != mid)
if (*iter == some_val)
iv.insert(iter, 2 * some_val);
循环不会结束
迭代器可能会失效
要改为下面这样：

while (iter != mid)
{
if (*iter == some_val)
{
iter = v.insert(iter, 2 * some_val);
++iter;
}
++iter;
}

使用下面代码定义的ia，将ia
拷贝到一个vector和一个list中。是用单迭代器版本的erase从list中删除奇数元素，从vector中删除偶数元素。

int ia[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89 };
vector vec(ia, end(ia));
list lst(vec.begin(), vec.end());

for (auto it = lst.begin(); it != lst.end(); )
if (*it & 0x1)
it = lst.erase(it);
else
++it;

for (auto it = vec.begin(); it != vec.end(); )
if (!(*it & 0x1))
it = vec.erase(it);
else
++it;

编写函数，接受一个forward_list和两个string共三个参数。函数应在链表中查找第一个string，并将第二个string插入到紧接着第一个string之后的位置。若第一个string未在链表中，则将第二个string插入到链表末尾。

void find_and_insert(forward_list& flst, const string& s1, const string& s2)
{
auto prev = flst.before_begin();
auto curr = flst.begin();
while (curr != flst.end())
{
if (*curr == s1)
{
flst.insert_after(curr, s2);
return;
}
prev = curr;
++curr;
}
flst.insert_after(prev, s2);
}

假定vec包含25个元素，那么vec.resize(100)会做什么？如果接下来调用vec.resize(10)会做什么？

将75个值为0的元素添加到vec的末尾
从vec的末尾删除90个元素

接受单个参数的resize版本对元素类型有什么限制（如果有的话）？

元素类型必须提供一个默认构造函数。