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个元素为0
array<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都是除了无序的关联容器之外的容器