由浅入深-顺序容器(vector deque list)

 

1 初始化
    //元素类型要求,必须能复制和复制;如输入输出流和引用不可以
    vector<int> v1;//空
    vector<int> v2(v1);//其他容器
    vector<int> v3(v1.begin(),v1.end());//迭代器
    vector<int> v4(3,0);//n个0
    vector<int> v5(3);//n,不指定值则调用默认构造函数,前提容器类型要有默认构造函数
    int iarray[]={1,2,3,4};
    vector<int> v6(iarray,iarray+4);//用指针初始,类似迭代器

    list< deque<int> > list1;//复杂元素类型,注意尖括号要有距离

2 迭代器支持的操作

--常用
    //*iter;
    //iter->mem;mem表示为迭代器指向对象的成员,如vector<string>的迭代器iter,iter->size();

               表示该iter指向元素的size()
    //--iter;++iter;iter--;iter++
    //iter1==iter2;iter1!=inter2 指向同一元素则相等,反之不相等
--vector和deque
    //iter+n;iter-n
    //iter1+=inter2;iter1-=inter2; 疑问,没实现
    //iter1-iter2;返回位置差,可能正数或负数
    //>,<,<=,>= 同一个容易,位置越靠后越大

3 阶段示例一

vector<int>::iterator _vector_2(vector<int>::iterator ibegin,vector<int>::iterator iend,int i)
{
    while(ibegin!=iend)
    {
        if(*ibegin==i) return ibegin;
        ibegin++;
    }
    return ibegin; //没找到,则ibegin和iend相等
}

-------------------------------

#include <iostream.h> 
#include <vector.h>
#include <string>

using namespace std; //string

vector<int>::iterator _vector_2(vector<int>::iterator ibegin,vector<int>::iterator iend,int i);

void main()

{

    vector<int> v7;
    v7.push_back(1);
    v7.push_back(2);
    v7.push_back(3);

 

    if((_vector_2(v7.begin(),v7.end(),7))!=v7.end())
    {
        cout<<*(_vector_2(v7.begin(),v7.end(),2))<<endl;

        //调用函数要先进行判断是否返回和end()相同,相同则不能解引用
    }else{
        cout<<"没有该值!!"<<endl;
    }

}

4 顺序容器的操作-----示例可参考<由浅入深-string>

--1)容器定义的类型别名

    size_type               //无符号整型,一般用来存储容器的长度
    difference_type         //存储两个迭代器迭代器的差值,可为负数
    iterator                //容器的迭代器类型
    const_iterator          //元素只读迭代器类型
    reverse_iterator        //按逆序寻址的元素迭代器类型
    const_reverse_iterator
    value_type              //元素类型-
    reference               //元素的左值类型
    const_reference         //元素的常量左值类型

--2)begin,end,rbegin,rend成员

    string s10("hello world");

    string::reverse_iterator iter2=s10.rbegin();
    string s13(s10.rbegin(),s10.rend());
    string s14(iter2,iter2+s10.size());
    cout<<s13<<endl;        //dlrod olleh
    cout<<s14<<endl;

--3)添加元素操作

    c.push_back(t)          //最后位插入t元素
    c.insert(p,t)           //p位置前插入t元素
    c.insert(p,n,t)         //p位置前插入n个t
    c.insert(p,b,e)         //p位置前插入迭代器b到e标识的范围

--4)容器大小操作

    c.size()                //容器中元素个数

    c.empty()               //标记容器大小是否为空,bool,空则返回ture

    c.max_size()            //容器最大可容纳的个数
    c.resize(n)             //调整容器的长度,使得能容纳n个
    c.resize(n,t)           //调整容器的长度,n位都为t元素

--5)访问容器内元素的操作

    c.back()                //返回容器中最后一个元素的引用

    c.front()               //返回容器中第一个元素的引用

    c[n]                    //下标在[0,size()),只能用于vector和deque
    c.at(n)                 //返回下表n的元素的引用,不能越界

--6)删除元素操作

    c.erase(p)              //删除迭代器p所指向的元素
    c.erase(b,e)            //删除b,e区间的元素
    c.clear()               //全部删除

    c.pop_back()            //删除最后一个元素,返回void,容器不能为空

    c.pop_front()           //删除一个元素,容器不能为空

--7)赋值与swap操作
    s1.swap(s2)             //s1和s2的值交换
    s1.assign(b,e)          //重新赋值,迭代器b到e范围间的值
    s1.assign(n,t)          //重新赋值,n个t

    //不同容器(或相同)类型的容器内,元素类型不相同但是互相兼容,就要用assign,不用=号赋值

--8)capacity和reserve成员

----capacity()容量和,size()的区别;size()说明是容器现有的元素个数,capacity()说的是可以有的元素的个数;一般capacity比size大,空容器都为0;....至于capacity分配策略不是特别清晰!!!

----reserve,可以定义改变capacity,好处是加快容器插入速度;

    当容器capacity为50,在插入第51个元素的时候,会先重新分配空间,把原来50个元素放到新的空间里面.然后在插入新元素..先reserve保证空间够用就不会出现类似情况了

--9)容器间的比较

   v1>v2  < <= >= !=

   容器类型,及其容器元素类型都相同才能比较,依次比较元素大小..

--10容器比较 vector deque list

--vector deque

优点:按顺序存储,访问速度快(可以用偏移量p+n,可用下标)

缺点:vector在非尾部,插入或者删除数据时,为保证顺序存储,其他元素会相应移动位置

     deque同理,在非头部尾部,删除删除,位置的移动的开销都比较大

--list

缺点:元素访问开销大,不是顺序存储,如指针指向5元素,要想访问10元素,必须先遍历5和10间的元素才能访问到;(不能用偏移量和下标)

优点:任何位置插入,删除数据的时候,都不必移动位置.

 

--选用容器,则看需要看改容器经常的操作;

  如果又经常插入,有随机访问,尽量使用迭代器,不使用下标,则可方便list和vector的切换;

  也可list和vector混合使用,如在插入数据的时候使用list,然后赋值给vector

 

 5 容器适配器---实际意义??

标准库提供了三种顺序容器适配器：queue、priority_queue、stack.适配器是标准库中通用的
概念，包括容器适配器、迭代器适配器和函数适配器。本质上，适配器是使一事物的行为类似于另
一类事物的行为的一种机制。容器适配器让一种已存在的容器类型采用另一种不同的抽象类型的工
作方式实现。例如，stack适配器可使任何一种顺序容器以栈的方式工作。如下列出了所有容器适配
器通用的操作和类型。
size_type               一种类型，足以存储此适配器类型最大对象的长度
value_type             元素类型
container_type      基础容器类型，适配器在此容器类型上实现
A  a;                       创建一个新的空适配器，命名为a
A  a(c);                   创建一个名为a的新适配器，初始化为容器c的副本
关系操作符             所有适配器都支持全部关系操作符：==、！=、<、<=、>、>=
使用适配器时，必须包含相关的头文件：
#include<stack>         #include<queue>

适配器的初始化
deque<int> deq;
stack<int> stk(deq);  //将deq中的元素复制到stk中

覆盖基础容器类型
默认的stack和queue都基于deque容器实现，而priority_queue则在vector容器上实现。在创建适
配器时，通过将一个顺序容器指定为适配器的第二个类型实参，可覆盖其关联的基础容器类型：
stack< string, vector<string> > str_stk;
stack< string, vector<string> > str_stk(svec);
对于给定的适配器，其关联的容器必须满足一定的约束条件。stack适配器所关联的基础容器可以是
任何一种顺序容器类型。因此，stack栈可以建立在vector、list、deque容器之上。而queue适配器
要求其关联的基础容器必须提供push_front运算，因此只能建立在list和deque容器上，而不能建立
在vector容器上。priority_queue适配器要求提供随机访问功能，因此可建立vector或deque容器上，
但不能建立在list容器上。

适配器的关系运算
两个相同类型的适配器可以做==、！=、<、<=、>、>= 关系比较，只要基础元素类型支持等于和小
于操作符即可。这些关系运算由元素依次比较来实现。第一对不相等的元素将决定两者之间的小于
或大于关系。

栈适配器

s.empty()                如果栈为空，返回true,否则返回false
s.size()                    返回栈中元素的个数
s.pop()                    删除栈顶元素，但不返回其值
s.top()                    返回栈顶元素，但不删除其值
s.push(item)           在栈顶压入新元素

队列和优先级队列

q.empty()         如果对列为空，返回true,否则返回false
q.size()             返回队列中元素的个数
q.pop()             删除队列首元素，但不返回其值
q.front()           返回队列首元素的值，但不删除该元素   该操作适用于queue而非priority_queque
q.back()           返回队尾元素的值，而不删除该元素       该操作适用于queue而非priority_queque
q.top()             返回具有最高优先级的元素值，但不删除该元素       该操作适用于priority_queque
q.push(item)   对于queue，在队尾压入一个新元素
对于priority_queue,在基于优先级的适当位置插入新元素

注意：所有容器适配器都根据其基础容器类型所支持的操作来定义自己的操作。例如，默认情况下
栈适配器建立在deque容器上，因此采用deque提供的操作来实现栈功能。比如说，执行下面的语
句 intStack.push(ix++); 这个操作通过调用push_back操作来实现，而该push_back操作由intStack
所基于的deque对象提供。尽管栈是以deque容器为基础实现的，但是程序员不能直接访问deque
所提供的操作。不能在栈上调用push_back函数，而是必须使用栈所提供的名为push的操作。

 

(2011-10-30 11:28:40)