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 =  ;i < num_size;i++)
         cout<<vec[i]<<endl;

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

 }

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

     const vector<int>::size_type a_size = ;
     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[] = {,,,,};
     vector<int> vec(num,num+);
     if(find_num(vec.begin(),vec.end(),))
         cout<<"find"<<endl;
     else
         cout<<"can't find";
     return ;
 }

 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,);
     ++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()<<endl;　　//检查越界
         cout<<*vec.begin()<<endl;
         cout<<vec.front()<<endl;
     return ;
 }

删除元素

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[] = {,,,,};
     vector<int> vec(num,num+);
     cout<<vec.back()<<endl;
     vec.pop_back(); //vector没有pop_front方法
     cout<<vec.back()<<endl;

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

     return ;
 }

　

9.26 删除迭代器中偶数元素

int main()
{
    int ia[] = {,,,,,,,,,,};
    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)% == )
            vite = vec.erase(vite);
        else
            ++vite;
    }
    vite = vec.begin();
    while(vite != vec.end())
        cout<<*vite++<<" ";

    return ;
}

赋值与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容器上（因为需要随机访问）