定義容器的類型有三種限制

偶們能夠定義的容器的類型有三個限制：

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;

    };