c++ STL 006 容器（vector）

类模板原型

class template

std::vector

template < class T, class Alloc = allocator > class vector;

说明

1. vector 可以看成是一个动态数组，这个数组是可以动态扩容或者缩减的。
2. Internally, vectors use a dynamically allocated array to store their elements. This array may need to be reallocated in order to grow in size when new elements are inserted, which implies allocating a new array and moving all elements to it. This is a relatively expensive task in terms of processing time, and thus, vectors do not reallocate each time an element is added to the container.（大意是说他是一个可以动态分配元素的数组，当已经分配好的容量不足时，会重新分配一块更大的内存空间来储存元素，这些储存的元素有一部分是从原数组中复制过来的，新增的部分则在复制的元素后面进行添加）
3. vector 在内存消耗上比array更大，但是在扩容和元素操作上比数组更加有效率
4. 相比与其他容器来说，vector读写效率会更高。(Compared to the other dynamic sequence containers (deques, lists and forward_lists), vectors are very efficient accessing its elements (just like arrays) and relatively efficient adding or removing elements from its end. )

模板参数

< class T, class Alloc = allocator >

1. T 存放在vector中的数据类型
2. 与T对应的分配器，一般情况不需要传入，使用默认的容器分配器就可以了。

成员类型

可能会作为成员函数的返回值类型。

成员函数、非成员函数、其他

示例及说明：

#include 
#include 

using namespace std;

int main(){
    //声明vector对象，其中的元素类型为int数据对象。
    vector<int> vec1;

    // vec1 分配100个元素，每个元素的值为30的vector对象。
    vec1.assign(100,31);

    cout << vec1.size() << endl;

    // vec1 再次分配数据的时候，原先的数据及空间将会被销毁掉，重新进行数据空间的分配
    // (这个前提是数据扩张的情况下，数据缩减的时候不进行如此的操作，只将需要的数据进行重新分配)。
    vec1.assign(20,34);

    cout << vec1.size() << endl;

    // 返回一个引用，这个引用是vec1中指定位置的元素，索引值从0开始
    cout << vec1.at(1) << endl;
    cout << typeid(vec1.at(1)).name() << endl ; // 返回值为 i， 表示整数
    // 也可以使用[index] 操作符来获取数据
    cout << vec1[40] << endl;


    //back 返回最后一个元素直接的引用
    // A reference to the last element in the vector.
    cout << vec1.back() << endl; //34

    // FRONT 返回第一个元素的直接引用
     cout << vec1.front() << endl;

    //  end() 返回的是vector最后元素的迭代器对象，而不是最后一个元素的引用
    // 文档说明：Unlike member vector::end, which returns an iterator just past this element, this function returns a direct reference.
    cout << *vec1.end() << endl;

    // begin() 返回vector容器序列的最开始的一个迭代器
    cout << *vec1.begin() << endl;
    for (auto i= vec1.begin();  i != vec1.end() ; ++i) {
        // auto vector::iterator
        cout << *i << endl;
    }
    /**
     * 其对应的：
     *      cbegin cend 表示返回的是一个常量的迭代器  vector::const_iterator
     *      rbegin rend  表示返回的是一个反向迭代器，即倒序读取数据 vector::reverse_iterator
     *      crbegin crend 表示返回的是一个常量反向迭代器。 vector::const_reverse_iterator
     */


    //vec1 容器目前所能够存放的最多数据，及在不进行扩容的前提下所可以容纳的元素个数
    cout << vec1.capacity() << endl; //128
    //在当前的环境中容器所能够扩容到的最大元素个数，环境不同得到的数不同
    cout << vec1.max_size() << endl; //4611686018427387903
    // 容器所已经存放数据所占据的大小
    cout << vec1.size() << endl;


     //vec1.clear() ; // 容器清空

     cout << vec1.size() << endl; //0

     //Returns a direct pointer to the memory array used internally by the vector to store its owned elements.
     //返回首元素指针
     cout << *vec1.data() << endl;


     //元素的插入
     // emplace 指定位置(这个位置使用迭代器参数)插入元素，返回一个迭代器对象
     //这个迭代器是一个随机访问迭代器，即可以随时访问容器中任意元素的迭代器。
     auto i = vec1.emplace(vec1.begin()+6,12345);
     cout << typeid(i).name() << endl;
     cout << vec1[6] << endl; //12345

     // emlpace_back() 末尾追加元素
     vec1.emplace_back(123);
     cout << vec1[21] << endl; //123

     /**
      * 可以使用insert进行插入操作
      * 函数原型：
      *
      *     iterator insert (const_iterator position, const value_type& val);

             iterator insert (const_iterator position, size_type n, const value_type& val);

            template 
            iterator insert (const_iterator position, InputIterator first, InputIterator last);

            iterator insert (const_iterator position, value_type&& val);

            iterator insert (const_iterator position, initializer_list il);

            示例：
                std::vector myvector (3,100);
              std::vector::iterator it;

              it = myvector.begin();
              it = myvector.insert ( it , 200 );

              myvector.insert (it,2,300);

              // "it" no longer valid, get a new one:
              it = myvector.begin();

              std::vector anothervector (2,400);
              myvector.insert (it+2,anothervector.begin(),anothervector.end());

              int myarray [] = { 501,502,503 };
              myvector.insert (myvector.begin(), myarray, myarray+3);

              std::cout << "myvector contains:";
              for (it=myvector.begin(); it

     //empty 判断容器是否为空
     //true if the container size is 0, false otherwise.
     cout << vec1.empty() << endl;


     //erase 删除容器中指定的元素，可以是单个，也可以是序列元素，参数为迭代器对象
     /**
      * 返回迭代器对象，函数原型
      * iterator erase (const_iterator position);
        iterator erase (const_iterator first, const_iterator last);
      */

    vec1.erase (vec1.begin()+5);
    vec1.erase (vec1.begin(),vec1.begin()+3);
    for (auto j = vec1.begin(); j != vec1.end() ; ++j) {
        cout << *j << ","; //34,34,12345,34,34,34,34,34,34,34,34,34,34,34,34,34,34,123,
    }

    //向末尾追加元素
    vec1.push_back(111);
    //移除最后一个元素
    vec1.pop_back();

    /**
     * 容器的大小调整使用： resize， reserve
     */

    return 0;

}