c++primer顺序容器知识点 第九章课后题

1. vector的初始化

    vector<int> v1(10); // v1里面有10个元素 都是0    vector<int> v2{10}; // v2里面有一个元素 10;    vector<int> v3(10, 1); // v3里面有10个元素都是1    vector<int> v4{10, 1}; // v4里面有连个元素10,1;    // string容器初始化    vector<string> v5{"hi"}; // 列表初始化 v5有一个元素      //注意    vector<string> v6("hi"); //错误,不能使用字面值构建vector对象    vector<string> v7{10};   // v7有10个默认初始化的元素    vector<string> v8{10, "hi"}  // v8有10个"hi"元素    vector<string> v9(10, "hi") // 和v8一样    vector<int> vec; //空容器    vector<int> vec2(vec1);  // 两对象和元素必须是同一类型    ~~~~~~~~    vec2 = vec1;    ~~          vec{1, 2, 3};    ~~          vec = {1, 2, 3};    ~~          vec(b, e); b和e指定范围中元素的拷贝     只有顺序容器的构造函数才能接受大写参数(不包括array)    ~~          vec(10);     ~~          vec(3, 4);    int a[5] = {1, 2, 3, 4, 5};   // 字符容器也是如此    vector<int>v1 (begin(a), end(a));    vector<int> v2(a, a+5);  // 范围初始化    vector<vector<string>> lines// lines是一个vector 其元素类型是string的vector

1. 知识点:
   当将一个容器初始化为另一个容器的拷贝时,两个容器的类型和元素类型必须相同.
   但是如果是用范围来初始化只需元素类型相同

vector<int> vec;list<int> vec2(vec.begin(), vec.end());

• array:

标准库中的array:必须指明类型和大小array<int, 10>;  // int类型, 10个元素为0array<string, 10>; // string类型,10个空串;array<int, 10>::size_type i ;传参时用 或者定义循环变量数组初始化: array<int, 10> a1;array<int, 10> a1 = {1, 2, 3 }; //列表初始化 剩余为0注意内置数组不能拷贝而array可以int a[10]; int b[10] = a;  // 错误array<int, 10> a;  array<int, 10> b = a; //正确但是要注意类型和大小要一致

9.11:
见上面知识点
9.12
接受一个容器是拷贝整个容器的内容
接受两个迭代器是拷贝连个迭代器之间的内容,并且只要求元素类型可以转化就行

9.13

//问题:如何从一个list<int>初始化一个vector<double> 从一个//vector<int>又该如何创建#include <iostream>#include <vector>#include <list>using namespace std;int main(){    list<double>list1 = {1.1, 2.4, 3, 4};    vector<int> vec (list1.begin(), list1.end());    auto it = vec.begin();    auto it1 = list1.begin();    cout<< "拷贝前: " ;    while(it1 != list1.end())  // 原来的    {        cout << *it1 << " ";        ++it1;    }    cout << endl;    cout << "拷贝后: ";    while (it != vec.end())  // 拷贝过来的    {        cout << * it << " ";        ++it;    }    cout << endl;    return 0;} 相同数据类型的容器可以拷贝 

1.顺序容器类型:

• vector 可变数组大小,支持快速随机访问,在尾部之外的位置插入或删除元素可能会很慢
• deque 双端队列, 支持快速随机访问.在头尾部插入/删除速度很快
• list 双向链表,只支持双向顺序访问.在list中任何位置进行插入/删除速度都很快

• forward_list 单向

  ---

  2.关于拷贝后元素的强制转换:

#include <vector>#include <list>using namespace std;int main(){    list<double>list1 = {1.1, 2.4, 3, 4};    vector<int> vec (list1.begin(), list1.end());    auto it = vec.begin();    auto it1 = list1.begin();    cout<< "拷贝前: " ;    while(it1 != list1.end())  // 原来的    {        cout << *it1 << " ";        ++it1;    }    cout << endl;    cout << "拷贝后: ";    while (it != vec.end())  // 拷贝过来的    {        cout << * it << " ";        ++it;    }    cout << endl;    return 0;}//运行结果拷贝前: 1.1 2.4 3 4 拷贝后: 1 2 3 4 

链表,只支持单向顺序访问.在链表中任意个位置插入/删除速度都很快
array 固定大小数组,支持快速随机访问,不能增加删除元素
string 与vector相似的容器,但是专门用于保存字符,随机访问快,在尾部插入/删除速度快
建议:
使用vector是最好的选择,除非你有更好理由选择其他容器

• 顺序容器的操作注意要看 295页
• 迭代器中 注意gorward_list 不支持递减运算符(–) 特例
• 迭代器范围:begin ,end; begin表示首元素迭代器,end表示尾元素的下一个位置的迭代器.其区间是[begin, end)
• 迭代器类型:

vector<int>::iterator it; // it能读vector<int>元素string::iterator it2; // it2能读string对象的字符vector<int>:: const_iterator it3;// it3只能读元素,不能写元素string::const_iterator it4; // it4只能读元素,不能写元素

9.6 vector<int>::size_type类型// 代表无符号整数类型

9.7 list<string>::iterator || :: const_iterator // 读::iterator // 写

list<string> a{"hello", "world"};auto it1 = a.begin();// it1是list<string>::iterator 类型auto it2 = a.cbegin(); // it2是list<string>::const_iterator类型auto it3 = a.rbegin(); // it3是~~    ::reverse_iterator反向迭代器auto it4 = a.crbegin(); // it4是~~~:: const_reverse_iterator类型end()与此类似是去const_iterator 还是 iterator取决于a的类型是不是const 当不需要访问时最好用cbegin();

9.9:cbgein()返回的是const_iterator 不能被修改而begin()可以看例子#include <iostream>#include <vector>#include <iterator>using namespace std;vector<int>::const_iterator find(vector<int>::const_iterator begin,      vector<int>::const_iterator end, int i){ // 此时*begin不可以被修改    while (begin != end)    {        if (*begin == i)              return begin;  // 找到返回该元素迭代器        ++begin;    }    return end; // 未找到返回最后一个迭代器}int main(){    vector<int> vec{1, 3, 4, 5, 6 };    cout << "请输入要查找的值" << endl;    int i;    cin >> i;    auto a = find(vec.cbegin(), vec.cend(), i);    if (a != vec.cend())        cout << "找到" << endl;    else        cout << "未找到" << endl;    return 0;}

9.10特别注意it1 是vector<int>::iterator;it2 是const vector<int>::iterator;it3 是vector<int>::const_iterator;it4 是const<int>::cosnt_iterator;

const vector <int> ::iterator和vector <int>::const_iterator有什么不同

const vector::iterator中，const是修饰的迭代器，也就是是个常迭代器，一旦初始化比如=a.begin()，再不能更改它的值，比如赋值=a.end()是不行的，递增递减操作等都不允许。
虽然类似指针，但指针是内置类型，所以编译器可以通过const的位置来判断是常指针还是指向常量的指针，而迭代器只是一个对象，所以编译器不能分辨，所以用const_iterator来取代指向常量的指针，使用它，你通过这个迭代器对迭代器所指向的内容进行改写是非法的。
看代码:

通过简单的代码区别,更能说明问题,

  vector<int> ivec;  vector<int>::const_iterator citer1 = ivec.begin();  const vector<int>::iterator citer2 = ivec.begin();  *citer1 = 1; //error  *citer2 = 1; //right  ++citer1; //right  ++citer2; //error

• swap :
  2、使用swap：类型必须相同(容器类型和元素类型)
  3、使用assign(仅顺序容器)：类型兼容即可(容器类型相同,元素类型兼容就行) 替换

  关于swap 对array交换迭代器等会失效 其他不会

仔细看:

#include <iostream>#include <list>#include <vector>using namespace std;int main(){    vector<int> vec = {1, 2, 3, 4};    vector<int> vec1 = {4, 3, 2,1};    cout << "交换前 vec为: ";    for (auto i : vec)    {        cout << i;    }    cout << endl;    auto it = vec.begin();    cout << "交换前v的it指向的是 "<<*it <<endl;    auto it1 = vec1.begin();    cout << "交换前v1的it1迭代器指向的是 :"<<*it1 << endl;    vec1.swap(vec); // 交换两个容器    cout << "交换后vec 为";    for (auto i : vec)    {        cout << i ;    }    cout << endl;    cout << "交换后v原来的it现在指向" << *it <<endl;    cout << "交换后v1原来的it1现在指向" << *it <<endl;    return 0;}

/*   若交换前定义一个it 指向元素值为1 的迭代器,交换后it还是指向1,改变的只是容器内部的数据结构   交换后迭代器不变 ,引用, 指针都不变    但是容器的数据类型必须一样  如果是对string调用swap则迭代器等会失效   一、赋值与交换1、c1 = c2;2、c1.swap(c2);3、c1.assign(b,e);//b和e是两个迭代器4、c1.assign(n,t);//n个t二、使用swap：类型必须相同(容器类型和元素类型)三、使用assign：类型兼容即可(容器类型相同,元素类型兼容就行) */

9.14

#include <iostream>#include <list>#include <vector>using namespace std;// 使用assign 只需要元素类型可以转换就好了int main(){    list <const char *> list1={"hello", "world"};    vector<string> vec(list1.cbegin(), list1.cend());  // 初始化也行//  vec.assign(list1.cbegin(), list1.cend());       for (const auto &i : vec)    {        cout << i << endl;    }    return 0;}

比较:
假设c1和c2是容器，什么（如果有的话）约束对c1和c2的类型有下列用途？
首先，必须有相同的容器和相同的类型。二，持有的类型必须支持关系操作。

c1和c2都是除了无序的关联容器之外的容器