自从上一次学习STL的组件（string）已经过去有些日子了，主要是还在进行其他方面的学习，现在有了空闲继续来总结C++STL方面，vectot也是很早之前就学过的部分，学习过程中也是让我深深感到了C++STL的实用，现在在做有关方面的题目时有的地方会忘记（所以总结顺便复习），总之要学习和总结的东西还有很多，就请路过的看客和我一起学习前进吧。-----(≧∇≦)ﾉ

首先是关于vector的介绍

经过之前一遍学习后，我也大致了解了vector的学习步骤，我将其分为以下三个部分：

有人可能会问那一条红线？那是与之相关的内容，也是我最近在学习的部分之一，下一次的内容就是他了（当然还是STL相关的，我学的慢。。。）

然后当然就是给出vector的定义了！

由于了解到定义这一部分也是蛮重要的知识点内容，所以我将此详细总结了一下，如下：

  1. vector是表示可变大小数组的序列容器

  2. 像数组一样，vector也采用的连续存储空间来存储元素，可以采用下标对vector的元素进行访问

  3. 和数组不同，vector的大小是可以动态改变的，而且它的大小会被容器自动处理（kksk^_^）

  4. 本质上讲，vector使用动态分配数组来存储它的元素，当新元素插入时候，这个数组为了增加存储空间需要被重新分配大小，具体做法是 “分配一个新的数组，然后将全部元素移到这个数组”

  5. vector分配空间策略是：

    • vector会分配一些额外的空间以适应可能的增长，所以存储空间比实际需要的存储空 间更大

    • 虽然不同的库采用不同的策略权衡空间的使用和重新分配，但是无论如何，重新分配 对数增长的间隔大小，以至于在末尾插入一个元素的时间都应该是在常数时间的复杂 度内完成的
  6. 与其它动态序列容器相比（deque、 list 、 forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率较低。

再再来到最最重要的使用环节！

首先是vector内所包含的接口有哪些：

1.构造函数使用：
构造函数上的使用有以下四种

* vector（）                                                                                无参构造
* vector（size_type n, const value_type& val = value_type()    构造并初始化n个val
* vector (const vector& x)                                                           拷贝构造
* vector (InputIterator first, InputIterator last)                             使用迭代器进行初始化构造

vector的这四种构造函数中最常用的就是
无参构造函数vector（）和拷贝构造vector (const vector& x)
第二种构造vector（size_type n, const value_type& val = value_type() 看场合使用即可
而关于第4种构造 在这里先跳过，毕竟迭代器相关我还没有学习，之后跟进的博客到达迭代器部分的时候再说

2.vector提供的迭代器（iterator）使用：
也就是以下两组

  • begin + end 获取第一个数据位置iterator/const_iterator， 获取最后一个数据的下一个位置的iterator/const_iterator

  • rbegin + rend 获取最后一个数据位置的reverse_iterator， 获取第一个数据前一个位置的reverseiterat

画个图的话差不多是这种感觉（画画苦手）：

此处只总结迭代器的使用方法：
eg1： const对象使用const迭代器进行遍历打印

vector::const_iterator it = v.begin();
//C++中可以使用auto关键字来代替上面一句it的类型部分，自动匹配数据的类型。
 while (it != v.end())
 {
 cout << *it << " ";
 ++it;
 }
 cout << endl;
}

eg2：使用迭代器进行遍历打印

 vector::iterator it = v.begin();//此句同上可使用auto关键字
 while (it != v.end())
 {
 cout << *it << " ";
 ++it;
 }

eg3：使用反向迭代器进行遍历再打印

 vector::reverse_iterator rit = v.rbegin(); //同上（没错就是懒得写）
 while (rit != v.rend())
 {
 cout << *rit << " ";
 ++rit;
 }

2.有关容量空间变化的接口
常用的有以下几种：

  • size 获取数据个数
  • capacity 获取容量大小
  • empty 判断是否为空
  • resize（重点） 改变vector的size
  • reserve （重点） 改变vector放入capacity

前三种接口都是常用且简单的，与string相似，所以这里不再做演示。
（注意，再次提醒capacity的增长是不固定的，具体增长多少是根据具体的需求定义
的，比方说：vs下capacity是按1.5倍增长的，g++是按2倍增长的，vs是PJ版本STL，g++是SGI版本STL）

主要需要注意的是resize和reserve两个函数：

  • reserve只负责开辟空间，如果确定知道需要用多少空间，reserve就可以缓解vector增容代价缺陷问题。

  • resize在开空间的同时还会进行初始化（对于扩大的那一部分空间），影响size
    此处给出两个使用例子：

eg1：

std::vector b;
 int sz = b.capacity();
 b.reserve(100);
 int ss=b.capacity();
 //可输出sz和ss来观察reserve效果

eg2：

std::vector a;
a.resize(5);
a.resize(8,100); 
a.resize(12);
//可通过同上手段来观察

3.vector内容增删查改操作相关接口
常用有如下几种：

  • push_back 尾插
  • pop_back 尾删
  • find 查找（算法模块实现，不是vector的成员接口）
  • insert 在position之前插入val
  • erase 删除position位置的数据，返回下一个位置的迭代器
  • swap 交换两个vector的数据空间
  • operator[] 像数组一样访问元素

其实我感觉上述这些接口都有用武之地，所以需要重点记忆的！

(1)push_back以及pop_back
eg:
vector a;
a.push_back(1);
a.push_back(2);
a.push_back(3);
a.push_back(4);
//此时a中内容为1 2 3 4
a.pop_back(3);
a.pop_back(4);
//此时a中内容为1 2

(2).operator[]（其实这个接口主要学习还是在模拟实现部分，这里给出使用例）
eg：
vector a;
a.push_back(1);
a.push_back(2);
a.push_back(3);
cout<< a[0]<//输出结果为123

(3).find
eg：
int a[] = { 1, 2, 3, 4 };
vector s(a, a+sizeof(a)/sizeof(int)) //vector可以将数组直接插入具体实现在模拟实现
auto it = find(v.begin(), v.end(), 3);
// 此时*it的值为3
//结果it为前两迭代器表示的范围内第一次找到3这个元素时的迭代器位置。

其他的几种具体实现和学习在模拟实现部分（耐心）

4.关于增删查改操作的接口有的时候还会导致迭代器的失效：
迭代器的失效产生的原因很多，这里举例常见的几种场景

（1）insert或者erase导致的迭代器失效

  • insert导致的情况： insert会导致迭代器失效，是因为insert可能会导致增容，增容后pos还指向原来的空间，而原来的空间已经释放了

  • erase导致的情况：删除pos位置的数据，会导致pos迭代器失效，此时再用pos迭代器进行访问就会出现程序错误。

（2）其他场景出现的迭代器失效

eg：
当进行以下操作时
auto it = a.begin();
while (it != a.end())
{
if (*it % 2 == 0) //简单的删除偶数
v.erase(it);
++it; //在这一步就会出现程序错误，因为erase已经将 it 变成了一个失效迭代器， } 对于失效的迭代器进行++会引发错误

那么问题来了，上面这段代码要怎么改呢？
由于erase接口被调用会返回删除位置的下一个位置，所以将代码改为以下这种就可以啦：
while (it != a.end())
{
if (*it % 2 == 0)
it = a.erase(it);
else
++it;
}

每当我学不动了时候我都会找张图片来细细观赏一番（洗眼睛），下面有请老婆登场：

（嘿嘿）
来来来现在我们继续，现在进入的就是最后的一部分啦，学完这里我们就可以放开手大胆的去用vector了（maybe~）：

vector的模拟实现（包括深度解析）

1.对vector深度解析
这一步是事关重要的，如果没有这一步的铺垫，要进行模拟实现就会难上加难，不清楚构造的东西自然难以实现
首先附上一张图来做说明（手绘勿喷）：

上图中：start表示指向数据块的开始
finish表示指向有效数据的尾
end_of_storage表示指向存储容量的尾

根据上面我画的这张图我们可以大致了解到vector的结构。
已上图为例，当a中元素超过capacity时，容量会扩充至两倍，若是两倍还不够则会扩充至足够大的容量。

注意：“但是扩容的步骤可不是直接在原来空间后面开辟空间这么简单，其中要经过重新配置、元素搬移、释放原空间等过程，是较为复杂的”

最后到了模拟实现的部分，部分需要注意的点会写在注释里：

namespace key{
    template
    class vector{
    public:
        // vector的迭代器是一个原生指针,所以做以下重定义方便实用
        typedef K* iterator;
        typedef const K* const_iterator;
        vector()                             //无参构造
            :_start(nullptr)                 //初始化列表
            , _finish(nullptr)
            , _endofstorage(nullptr){}

        vector(int n, const K& value = K())  //含参数构造，且初始化，插入n个value元素，第二个参数做缺省值可不填
            : _start(nullptr)
            , _finish(nullptr)
            , _endofstorage(nullptr){
            reserve(n);
            while (n--)
            {
                push_back(value);         //若是有第二个参数输入则初始化元素
            }
        }

        //所以重新声明迭代器，迭代器区间[first,last]可以是任意容器的迭代器
        template
        vector(InIterator first, InIterator last){
            reserve(last - first);
            while (first != last)
            {
                push_back(*first);
                ++first;
            }
        }
        vector(const vector& v)
            : _start(nullptr)
            , _finish(nullptr)
            , _endofstorage(nullptr){
            reserve(v.capacity());
            K* it = begin();
            K* vit = v.cbegin();
            while (vit != v.cend())
            {
                *it++ = *vit++;
            }
            _finish = _start + v.size();
            _endofstorage = _start + v.capacity();
        }
        vector& operator= (vector v){
            swap(v);
            return *this;
        }
        ~vector(){
            delete[] _start;
            _start = _finish = _endofstorage = nullptr;
        }

        // capacity
        size_t size() const { return _finish - _start; }
        size_t capacity() const { return _endofstorage - _start; }

        void reserve(size_t n){  //扩容，改变capacity的值
            if (n > capacity())
            {
                size_t oldSize = size();
                K* tmp = new K[n];
                if (_start)
                {
                    for (size_t i = 0; i < oldSize; ++i)
                        tmp[i] = _start[i];
                }
                _start = tmp;
                _finish = _start + size;
                _endofstorage = _start + n;
            }
        }

        void resize(size_t n, const K& value = K()){   //重新设定大小并初始化（部分）
            // 1.如果n小于当前的size，则数据个数缩小到n
            if (n <= size())
            {
                _finish = _start + n;
                return;
            }
            // 2.空间不够则增容
            if (n > capacity())
                reserve(n);
            // 3.将size扩大到n        //扩大的部分要初始化
            iterator it = _finish;
            iterator _finish = _start + n;
            while (it != _finish)
            {
                *it = value;
                ++it;
            }
        }
        ///////////////操作符重载///////////////////////////////
        T& operator[](size_t pos){ 
            return _start[pos]; 
        }
        const T& operator[](size_t pos)const {
            return _start[pos]; 
        }

        ///////////////增删查改/////////////////////////////
        void push_back(const K& x){     //后插
            insert(end(), x); 
        }
        void pop_back(){             //后删
            erase(--end()); 
        }

        void swap(vector& v){           //交换两个vector对象的数据空间
            swap(_start, v._start);
            swap(_finish, v._finish);
            swap(_endofstorage, v._endofstorage);
        }

        iterator insert(iterator pos, const K& x){   //插入
            assert(pos <= _finish);
            // 空间不够先进行增容
            if (_finish == _endofstorage)
            {
                size_t size = size();
                size_t newCapacity = (0 == capacity()) ? 1 : capacity() * 2;
                reserve(newCapacity);
                // 如果发生了增容，需要重置pos
                pos = _start + size;
            }
            K* end = _finish - 1;
            while (end >= pos)
            {
                *(end + 1) = *end;
                --end;
            }
            *pos = x;
            ++_finish;
            return pos;
        }
        // 返回删除数据的下一个数据
        // 方便解决:一边遍历一边删除的迭代器失效问题
        iterator erase(Iterator pos)
        {
            // 挪动数据进行删除
            iterator begin = pos + 1;
            while (begin != _finish) {
                *(begin - 1) = *begin;
                ++begin;
            }
            --_finish;
            return pos;
        }

        iterator begin() { return _start; }
        iterator end() { return _finish; }
        const_iterator cbegin() const { return _start; }
        const_iterator cend() const { return _finish; }

        private:
            iterator _start; // 指向数据块的开始
            iterator _finish; // 指向有效数据的尾
            iterator _endofstorage; //指向存储文件的尾

    };
}