Vector的一些方法

我们能够定义的容器的类型有三个限制： 
1. 元素类型必须支持等于操作符； 
2. 元素类型必须支持小于操作符；（其他所有关系操作符都有这两个操作符实现） 
3. 元素类型必须支持一个缺省值(对于类类型，即指缺省构造函数)
所有预定义的数据类型，包括指针以及C++标准库给出的类类型，都满足这些条件。

一些方法：
size();长度，当前所含元素的个数；
cpacity()；容量，容器在下一次需要增长自己之前，能够被加入到容器中的元素个数。
reserve();允许程序员将容器的容量设置成一个显式的指定值。reserve(10);
push_back();
insert();
begin();容器的第一个元素位置
end();容器的末元素的下一个位置；
empty();判空
resize();重新指定长度，新增的部分填入与元素低层类型相关联的缺省值，或指定值；
可以为容器指定一个显式的长度，长度可以使常量，也可以是非常量表达式。
vecotr <int> v(5);
v.resize(2*v.size());
v.resize(2*v.size(),8);

删除：
erase();删除一个或者一段元素
pop_back();删除容器末尾元素，不返回元素，只是简单删除。

template<class T, class A = allocator<T> >
    class vector {
public:
    typedef A allocator_type;
    typedef A::size_type size_type;
    typedef A::difference_type difference_type;
    typedef A::reference reference;
    typedef A::const_reference const_reference;
    typedef A::value_type value_type;
    typedef T0 iterator;
    typedef T1 const_iterator;
    typedef reverse_iterator<iterator, value_type,
        reference, A::pointer, difference_type>
            reverse_iterator;
    typedef reverse_iterator<const_iterator, value_type,
        const_reference, A::const_pointer, difference_type>
            const_reverse_iterator;
    explicit vector(const A& al = A());
    explicit vector(size_type n, const T& v = T(), const A& al = A());
    vector(const vector& x);
    vector(const_iterator first, const_iterator last,
        const A& al = A());
    void reserve(size_type n);
    size_type capacity() const;
    iterator begin();
    const_iterator begin() const;
    iterator end();
    iterator end() const;
    reverse_iterator rbegin();
    const_reverse_iterator rbegin() const;
    reverse_iterator rend();
    const_reverse_iterator rend() const;
    void resize(size_type n, T x = T());
    size_type size() const;
    size_type max_size() const;
    bool empty() const;
    A get_allocator() const;
    reference at(size_type pos);
    const_reference at(size_type pos) const;
    reference operator[](size_type pos);
    const_reference operator[](size_type pos);
    reference front();
    const_reference front() const;
    reference back();
    const_reference back() const;
    void push_back(const T& x);
    void pop_back();
    void assign(const_iterator first, const_iterator last);
    void assign(size_type n, const T& x = T());
    iterator insert(iterator it, const T& x = T());
    void insert(iterator it, size_type n, const T& x);
    void insert(iterator it,
        const_iterator first, const_iterator last);
    iterator erase(iterator it);
    iterator erase(iterator first, iterator last);
    void clear();
    void swap(vector x);
protected:
    A allocator;
    };