数据结构：向量Vector的实现与代码分析

Vector是比较常用的结构，在C++的STL中就有了vector的实现，在头文件<vector>中可以看到。

但是STL的实现就像一个超级大的蛋糕，我们不可能一口一口地吃下去。最好的办法是从基础的思想开始，自己跟着写一个简单版本的Vector。

vector究竟是什么？

其实本质上就是数组，只是经过封装后，可以忽略数组的长度限制。除了这一点，其他的特性跟数组都差不多。

对于队首和队中插入和删除都要耗费O(N)的时间，都是支持随机访问，其实这个就是本来的数组原来的操作，只是封了一层而已。

另外后面的算法研究，也会用到。

让我们把STL的各种数据结构，一点一点地吃掉。

下面看一下vector的C++实现和详细分析。这个是比C++ STL简单的版本，但是思想是一样的。

//
//  Vector.h
//  HelloWorld
//
//  Created by feiyin001 on 17/1/7.
//  Copyright (c) 2017年 FableGame. All rights reserved.
//

#ifndef __HelloWorld__Vector__
#define __HelloWorld__Vector__

template <typename Object>
class Vector
{
public:
    //默认构造函数，explicit是显式的意思，防止隐式转换，例如 Vector<int> a = 123;这类语句被编译成功
    //theSize 这个是对外的size，表示已经有多少个object在vector里面了。
    //theCapacity 这个是vector内数组实际的大小，SPARE_CAPACITY是预留的空间，防止每次插入的时候都要去重新申请一个数组。
    explicit Vector(int initSize = 0): theSize(initSize), theCapacity(initSize + SPARE_CAPACITY)
    {
        objects = new Object[theCapacity];//申请一个容量为theCapacity的动态数组，vector只是保留了数组的指针而已。
    }
    
    //复制构造函数，方便用现有的Vector对象，来创建一个新的对象。这里直接调用了复制赋值运算符。
    Vector(const Vector & rhs):objects(nullptr)
    {
        operator = (rhs);
    }
    
    //析构函数，构造函数里面的new和new[]一定要与析构函数里面的delete和delete[]对应，否则就是内存泄漏了。
    ~Vector()
    {
        delete [] objects;
    }
    
    //复制赋值运算符，将一个vector复制给另外一个。
    const Vector& operator=( const Vector& rhs )
    {
        if (this != & rhs)//如果地址相同，就不应该进行赋值了，直接返回
        {
            delete [] objects;//数组是不能直接复制的，它们有固定的大小，所以只能删除掉，然后新建一个一样大小的
            theSize = rhs.theSize;
            theCapacity = rhs.theCapacity;
            objects = new Object[rhs.theCapacity];
            //一个一个对象进行复制，如果Object内带有指针成员，这里一般要求Object是重载复制赋值运算符的，否则可能是浅复制了
            for (int k = 0; k < rhs.theSize; k++)
            {
                objects[k] = rhs.objects[k];
            }
        }
        return *this; //返回自身，是为了实现连续赋值的效果，例如vector<int> a,b,c; a = b = c;
    }
    
    //重置vector内对象的数量
    void resize(int newSize)
    {
        if (newSize > theCapacity)
        {
            reserve(newSize * 2 + 1);//新的大小是比原来的容量都打，才需要扩展容量，每次翻倍，之所以+1，是防止为0的情况。
        }
        theSize = newSize;//新的对象数量，如果比原来的多，则会多出一部分可能为初始化的值，如果比原来的小，则减少的部分对象就当做无效的数据了。
    }
    
    //修改vector的容量大小，
    void reserve(int newCapacity)
    {
        if (newCapacity < theSize)
        {
            return;//如果新的容量比现在实际的容量还小，是不需要更改的
        }
        Object* oldArray = objects;//旧的数据
        objects = new Object[newCapacity];//申请一个新的数组
        for (int k = 0; k < theSize; k++)
        {
            objects[k] = oldArray[k];//复制旧的数组给新的数组
        }
        theCapacity = newCapacity;//保存新的容量
        delete [] oldArray;//删除旧的数组
    }
    
    //重载了[]运算符，使得vector能够像基础的数组一样通过下标访问，带const的版本是在vector对象是const的时候使用的。
    Object & operator[](int index)
    {
        return objects[index];
    }
    const Object& operator[](int index) const
    {
        return objects[index];
    }
    
    //vector为空
    bool empty() const
    {
        return theSize == 0;
    }
    
    //返回对象的个数
    int size() const
    {
        return theSize;
    }
    
    //vector内数组实际的大小
    int capacity() const
    {
        return theCapacity;
    }
    
    //把对象放到数组尾，消耗的是O(1)的时间
    void push_back(const Object& x)
    {
        if (theSize == theCapacity)
        {
            reserve(2* theCapacity + 1);//如果已经所有位置都被使用了，就要扩容了
        }
        objects[theSize++] = x;//先赋值，再对theSize自增，记得C++的下标是从0开始id。
    }
    
    //弹出最后一个对象，直接把队尾往前移动就行了
    void pop_back()
    {
        theSize--;
    }
    
    //返回最后一个对象
    const Object& back() const
    {
        return objects[theSize - 1];
    }
    
    typedef Object* iterator;//迭代器
    typedef const Object* const_iterator;//常量的迭代器
    
    //开头的迭代器
    iterator begin()
    {
        return &objects[0];
    }
    const_iterator begin() const
    {
        return &objects[0];
    }
    
    //结尾的迭代器
    iterator end()
    {
        return &objects[size()];
    }
    const_iterator end() const
    {
        return &objects[size()];
    }
    
    //一些常量
    enum { SPARE_CAPACITY = 16 };//初始预留的容量
private:
    int theSize;//实际对象的数量，同时这标志着这个下标是队尾下一个的对象的下标，队尾的下标是theSize-1.
    int theCapacity;//数组实际的大小，每次theSize要超过的时候，才重新申请一个。
    Object* objects;//对象数组
};




#endif /* defined(__HelloWorld__Vector__) */

为了区分STL里面的vector，加了个域名Fable。没错，我就是肥宝。

下面看一下简单的测试代码。

//
//  main.cpp
//  HelloWorld
//
//  Created by feiyin001 on 17/01/04.
//  Copyright (c) 2016年 Fable. All rights reserved.
//

#include "Vector.h" 
#include <iostream>

using namespace Fable;


int main(int argc, char* argv[])
{
    //声明一个Vector<int>对象
    Vector<int> myVec;//编译到这里的时候，编译器就会生成了参数为int的Vector实例。
    
    //循环赋值
    for (int i = 0; i < 100; i++) {
        myVec.push_back(i);
    }
    
    //遍历，这里的迭代器，实际上只是Object*，当然STL里面的更加复杂，有更加丰富的实现。
    for (Vector<int>::iterator iter = myVec.begin(); iter != myVec.end(); ++iter) {
        std::cout << *iter << std::endl;
    }
    return 0;
}