c++ primer 9 顺序容器

定义：

#include <vector>
#include <list>
#include <deque>

    vector<int> svec;
    list<int> ilist;
    deque<int> items;

 

初始化：

1. 将一个容器初始化为另一个容器的副本

容器类型，元素类型必须相同

    vector<int> a;
    vector<double> d(a);
    
    list<double> b;
    vector<double> d(b);
     
    vector<double> c;
    vector<double> d(c);

只有最后一个是合法的

 

2. 初始化一段元素的副本

不能将一种容器内的元素赋值给另一个容器，但允许通过传递一对迭代器间接实现该功能。使用迭代器不要求容器类型相同，也不要求容器内元素类型相同，只要它们互相兼容

可以通过一个容器的迭代器初始化另一个容器，可以刻通过内置数组中的指针初始化容器（指针就是迭代器 ）

int main()
{
    char *num[] = {"one","two","three","fore","five"};  //用指针的方式初始化容器
    int num_size = sizeof(num)/sizeof(char *);
    vector<string> vec(num,num+num_size);
    for(int i = 0 ;i < num_size;i++)
        cout<<vec[i]<<endl;

    deque<string> deq(vec.begin(),vec.end());   //用迭代器初始化容器
    for(int i = 0 ;i < num_size;i++)
        cout<<deq[i]<<endl;

}

 

3. 分配和初始化指定数目的元素（只用于顺序容器）

    const vector<int>::size_type a_size = 10;
    vector<int> a(a_size);

初始化10个0（默认是0），size_type类型保存容器元素长度。

 

容器元素类型的约束

支持赋值运算和可以复制

容器的容器： eg:定义一个list对象来存储deque对象，该deque对象存放int型元素：list< deque<int> > lst;

注意两个相邻的< <之前必须有空格否则会被认为左移操作符

 

迭代器和迭代器范围

所有容器的迭代器都支持以解引用运算从容器中读入一个元素

所有容器迭代器都支持 *   ->   ++  --  ==  !=

vector,deque迭代可以进行算术运算和关系运算

list的迭代器不支持算术运算和关系运算（除了== !=）

9.9 逆序输出list:

int main()
{
    char *num[] = {"one","two","three","fore","five"};
    int num_size = sizeof(num)/sizeof(char *);
    list<string> lst(num,num+num_size);
    list<string>::iterator ite1 = lst.begin(),ite2 = lst.end();
    while(ite2 != ite1)
        cout<<*(--ite2)<<endl;
}

 

迭代器的范围的要求：

假设[first,last)

1. 指向同一容器中的元素或超出末端的下一个位置（所以用数组a初始化一个迭代器是(a,a+a_size)）

2. 如果这两个迭代器不想等，则对first反复做自增运算能达到last，就是last不能位于first之前

 

迭代器范围是左闭右开的意义：

1. first与last相等时迭代器为空

2. 不相等时迭代器范围内至少有一个元素

9.12  写一个形参是一对迭代器和int型整数，查找整数返回bool

bool find_num(vector<int>::iterator ite1,vector<int>::iterator ite2,int n);
int main()
{
    int num[] = {1,2,3,4,5};
    vector<int> vec(num,num+5);
    if(find_num(vec.begin(),vec.end(),5))
        cout<<"find"<<endl;
    else
        cout<<"can't find";
    return 0;
}

bool find_num(vector<int>::iterator ite1,vector<int>::iterator ite2,int n)
{
    while(ite1 != ite2)
    {
        if(*(ite1++) == n)
            return true;
    }
    return false;
}

 

迭代器失效

向容器中增加或删除元素会使迭代器失效，建议用end操作符返回的迭代器

vector<int>::iterator first = vec.begin(),last = vec.end();
while(first != last)    //不让其失效把last替换vec.end()
{
    first = v.insert(first,7);
    ++first;
}

 

 

顺序容器的操作 p272表格已列出

容器定义类型别名

size_type　　存储容器长度

iterator　　   此容器的迭代器类型

value_type　 元素类型，程序无须直接知道容器元素的真正类型就可以使用它

reference  　 该容器元素的引用，value_type&的同义词

 

c.begin()　　返回一个迭代器，指向c容器第一个元素

c.end()　　  返回一个迭代器，指向c容器的最后一个元素

 

c.push_back(t)　　在容器c的尾部添加值为t的元素，返回void类型

c.push_front(t)　  在容器c的前端添加值为t的元素，返回void类型（仅用于list和deque）

c.insert(p,t)　　　  在迭代器p前插入元素t

c.insert(p,n,t)　　  在迭代器p前插入n个元素t

c.insert(p,b,e)　　 在迭代器p前插入b,e之间的元素

　　

容器的比较

比较的容器必须有相同的容器类型，而且其元素类型也必须相同

容器的比较实际上就是元素的比较p277页例子

 

容器大小的操作

c.size()　　返回容器c中的元素个数

c.empty()  检查容器是否为空，返回bool

c.resize(n) 调整容器c的大小，当前容器大小大于新的长度，则容器后的元素就都删除，小于就添加新元素，可用（n,t）指定

 

访问元素

front和back成员，返回容器内第一个或最后一个元素的引用

.at()方式比用[]下标操作符的好的地方在于可以检查越界

注意list容器不能通过[]下标访问，也没有.at()方法，只能通过迭代器访问

 

9.24 三种方式获取容器第一个元素

int main()
{
    vector<int> vec;
    cout<<"Enter some intergers for vector(Ctrl + z to end)"<<endl;
    int num;
    while(cin>>num)
        vec.push_back(num);
    if(vec.empty())     //注意检查是否为空
        cout<<"No element"<<endl;
    else
        cout<<vec.at(0)<<endl;　　//检查越界
        cout<<*vec.begin()<<endl;
        cout<<vec.front()<<endl;
    return 0;
}

 

删除元素

c.erase(p)　　删除迭代器p指向的元素，返回一个迭代器（指向被删除元素后面的元素）

c.erase(b,e)   

c.clear()　　　删除容器内所有元素，返回void

c.pop_back()  删除容器c的最后一个元素，返回void

c.pop_front()  删除容器c的第一个元素，返回void（list，deque适用）

注意：pop_front和pop_back函数返回值不是被删除的元素而是void，要获取删除元素的值，则必须在删除元素之间调用front或back函数

练习.pop_back()和erase()删除其中一个元素，find方法在#include<algorithm>

#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>

int main()
{
    int num[] = {1,2,3,4,5};
    vector<int> vec(num,num+5);
    cout<<vec.back()<<endl;
    vec.pop_back(); //vector没有pop_front方法
    cout<<vec.back()<<endl;

    vector<int>::iterator ite;
    ite = find(vec.begin(),vec.end(),3);
    cout<<*ite<<endl;
    vec.erase(ite);

    return 0;
}

 

　

9.26 删除迭代器中偶数元素

int main()
{
    int ia[] = {0,1,1,2,3,5,8,13,21,55,89};
    int ia_size = sizeof(ia)/sizeof(int);
    vector<int> vec(ia,ia+ia_size);
    vector<int>::iterator vite = vec.begin();
    while(vite != vec.end())
    {
        if((*vite)%2 == 0)
            vite = vec.erase(vite);
        else
            ++vite;
    }
    vite = vec.begin();
    while(vite != vec.end())
        cout<<*vite++<<" ";

    return 0;
}

 

赋值与swap

c1 = c2 容器类型元素类型必须相同

c1.swap(c2)    也要求容器类型和元素类型都要相同,而且使用swap交换元素后,不会使原本指向这两个容器中的元素的迭代器失效,只不过他们都变成指向另一个迭代器中的相应位置了

c.assign(b,e)   b,e是一段迭代器，容器类型可以不同

 

vector容器自增长

c.capacity()  　　输出容器的容量

c.reserve(50) 　 预分配容器大小为50

 

容器选择：通常来说，除非找到选择使用其他容器更好的理由，否则vector容器都是最佳选择

 

string类型

可将string类型看作字符容器，和vector的操作类似，P289

 

容器适配器

stack　　栈

deque    队列

priority_queue　　有优先级管理的队列

stack可以和任意顺序容器关联，queue只能建立在list容器上（因为需要push_front操作），priority_queue建立在vector或者deque容器上（因为需要随机访问）