vector的使用

vector

vector是C++标准模板库中的部分内容，中文偶尔译作“容器”，但并不准确。它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。

【文件包含】
1，头文件#include<vector>
2，加上using namespace std;

【vector操作】
一，vector的初始化：
（1），vector<int> a(10);//定义10个int型元素的向量，每个元素值不确定。
（2），vector<int> a(10,1)//定义10个int型元素的向量，并且把每个元素赋初值1
（3），vector<int> a(b)//用b向量创建a向量。
（4），vector<int> a(b.begin(),b.begin()+2)//定义a值是b中第0个到第2个（共三个）元素。
（5），int b[] = {0,1,2,3,};vector<int> a(b,b+4)//从数组中获初值。
（6），vector <int> a = {0,1,2,3}//自定义初值

二，vector对象的常用操作函数！
vector::assgin( num , value ); 将新内容分配给向量，替换其当前内容，并相应地修改其大小。(nun是要分配的元素个数，value是每个元素的值)

vector <int> a;//其size = 0，capacity = 0；a.assgin(2,3);//size=2，capacity=2，a[0]=a[1]=3;

vector::front();返回容器中第一个元素的引用。
vector::back():返回容器中最后一个元素的引用。
vector::begin();返回容器中第一个元素的迭代器。
vector::end();返回容器中最后一个元素的下一个位置的迭代器。
vector::clear();删除容器的所有元素，使size=0，但是capacity不改变
vector::empty();判断容器是否为空，true表示容器size=0。
vector::push_back();在容器尾部插入

vector <int> a;a.push_back(0);a.push_back(1);a.push_back(2);

vector::pop_back();在容器尾部删除。
vector::erase迭代器删除
iterator erase(iterator pos);
iterator erase (iterator first, iterator last);

vector <int> a;    for (int i = 1; i <= 10; ++i)    {        a.push_back(i);    }    a.erase(a.begin() + 5);  //删除第5个位置的元素（从第0个位置开始）。还剩 1 2 3 4 5 7 8 9 10    a.erase(a.begin(), a.begin() + 5);//删除位置[0,5)第元素。还剩7 8 9 10

vector::insert插入
iterator insert (iterator pos, val);在pos位置插入val

a.insert(b.begin()+1,100);//在b的第1个位置（从第0个开始）100

void insert (iterator pos, n, val);在pos位置，插入n个val；

a.insert(b.begin()+1,3,100);//在b的第1个位置（从第0个开始）插入3个数，每个数都是100；

void insert (iterator pos, InputIterator first, InputIterator last)

vector <int> a;int b[] = {1,2,3,4};a.insert(a.begin(),b+1,b+3);//从a的第0个位置开始，插入b的第1个到第2个（不包括第3个）元素。

vector::size(); 返回容器中元素的个数；

vector <int> a = {0,1,2,3,4};int n = a.size;//n=5;

vector::capacity(); 返回容器在内存中总共可以容纳的元素个数
vector::a.resize(num); 将容器的现有元素个数调至num个，多则删，少则补，其值随机
vector::a.resize(num,value); 将a的现有元素个数调至num个，多则删，少则补，其值补为value

vector <int> a = {0,1,2}；a.resize(5);//size=5,其元素为0，1，2，0，0a.resize(8,2);//size=8，其元素为0，1，2，0，0，2，2，2

vector:: void reserve(newcapacity); 将a的容（capacity）扩充至newcapacity，但是当newcapacity< a.capacity时则不会发生变化。也就是说现在测试a.capacity();的时候返回值是newcapacity.这种操作只有在需要给a添加大量数据的时候才 显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能）

vector <int> a(10,10);//a.capacity=10a.reserve(100);//a.capacity=100;a.reserve(50);//capacity不会发生变化，还是100

vector:swap( vector & x ); 将a和x的元素全部交换

vector <int> a = {1,2,3};vector <int> b = {4,5,6,7,8};a.swap(b);//a是4，5，6，7，8；b是1，2，3

vector:operator [] (size_t pos);返回对矢量容器中位置n的元素的引用

vector <int> a={1,2,3,4};cout<<a[0]<<endl;//输出1

【误区，一种错误的操作】

vector <int> a;for(int i=0;i<10;++i){    a[i]=i;}//该操作是错误的，下标只能访问已存在的元素，而a[i]还没创建

【读取元素的方法】
1，下标访问

vector <int> a = {0,1,2,3,4};for(int i=0;i<a.size();++i){    cout<<a[i];}

2，通过遍历器方式

vector <int> a = {0,1,2,3,4};vector <int>::iterator it；for (i = d.begin(); i < d.end(); ++i){    cout << *i;} 

简单模拟实现vector

#include<iostream>#include<stdio.h>using namespace std;template <class T>class my_vector{public:    typedef T* Iterator;    my_vector()    {        _start = NULL;        _finish = NULL;        _endofstorage = NULL;    }    my_vector(size_t n, const T& value = T())  //构造函数，构造一个里面有n个相同值的顺序表        :_start(new T[n])    {        for (size_t idx = 0; idx<n; ++idx)            _start[idx] = value;        _finish = _start + n;        _endofstorage = _finish;    }     my_vector(const my_vector<T>& v)    {        size_t capacity = v._endofstorage - v._start;        _start = new T[capacity];        size_t size = v._finish - v._start;        for (size_t i = 0; i < size; ++i)        {            _start[i] = v._start[i];        }        _finish = _start + size;        _endofstorage = _start + capacity;    }    my_vector<T>& operator = (const my_vector<T>& v) //赋值运算符重载    {        if (this != &v)        {            size_type capacity = v._endofstorage - v._start;            size_type size = v._finish - v._start;            if (Capacity() < size)            {                _start = new T[capacity];                for (size_type idx = 0; idx<size; ++idx)                {                    _start[idx] = v._start[idx];                }                _finish = _start + size; //不能用_finish = v._finish;因为改变指向会引发错误                _endofstorage = _start + capacity;            }        }        return *this;    }    ~my_vector()    {        if (_start)        {            delete[] _start;            _start = NULL;            _finish = NULL;            _endofstorage = NULL;        }    }    Iterator Begin()    {        return _start;    }    Iterator End()    {        return _finish;    }    T& Front()    {        return *_start;    }    T& Back()    {        return*(--_finish);    }    size_t Capacity()const    {        return (_endofstorage - _start);    }    size_t Size()    {        return _finish - _start;    }    bool Empty()const//判断是否是为空    {        return _start == _finish;    }    T& operator[](size_t indix)    {        return _start[indix];    }    void PushBack(const T& x)//尾插    {        CheckCapacity();        Insert(_finish, x);    }    Iterator Insert(Iterator pos, const T& x)// 在pos位置上插入元素x    {        CheckCapacity();        Iterator it = _finish;        while (it > pos)        {            *it = *(it - 1);            --it;        }        *pos = x;        _finish++;        return pos;    }    Iterator Erase(Iterator pos)  // 删除pos位置上面的元素    {        Iterator it = pos;        while (it < _finish - 1)        {            *it = *(it + 1);            ++it;        }        --_finish;        return pos;    }private:    void CheckCapacity()    {        if (_finish >= _endofstorage)        {            size_t newcapacity = 2 * (_endofstorage - _start) + 3;            T* tmp = new T[newcapacity];            size_t size = _finish - _start;            for (size_t i = 0; i < size; ++i)            {                tmp[i] = _start[i];            }            delete[] _start;            _start = tmp;            _finish = _start + size;            _endofstorage = _start + newcapacity;        }    }    void Swap(my_vector<T>& V)    {        std::swap(_start, V._start);        std::swap(_finish, V._finish);        std::swap(_endofstorage, V._endofstorage);    }private:    Iterator _start;    Iterator _finish;    Iterator _endofstorage;};