(STL) vector的简单用法和实现

vector：能够操作多种数据结构和算法的模板类和函数库的C++标准模板库；是一个容器可以存放任意类型的对象，所以可以看作是一个能够存放任意类型的动态数组或顺序表。

STL里的vector是由三个指针来维护的：_start(数据存放开始的位置),_finish(数据存放结束位置的下一个),_endofstorage(容量的最后一个位置)。

Vector的简单使用：

^使用vector需要加上头文件#include<vector>；
^vector属于std命名域，前面需写上using namespace std;
^vector<int> vec(n);像数组一样可以存放n个int型数据；
^ vec[i]=2;像数组一样访问修改数据；
^可以装入自定义的数据类型

struct AA{ };
vector<AA> vec;

^定义容器的时候可以进行初始化，并可以给其他容器对象赋值

vector<int> vec1(15,0);//容纳15个int类型的数据，初值为0；
vector<int> vec2;
vec2=vec1;

^对于容器，使用迭代器操作容器中对应位置的值,当迭代器指向了容器中的某位置,则可以使用 * 加迭代器操作该位置了.

Vector函数实现功能：
vector vec;
vec.clear() 移除容器中所有数据。
vec.empty() 判断容器是否为空。
vec.erase(pos) 删除pos位置的数据
vec.insert(pos,elem) 在pos位置插入一个elem拷贝
vec.pop_back() 删除最后一个数据。
vec.push_back(elem) 在尾部加入一个数据。
vec.resize(num) 重新设置该容器的大小
vec.size() 回容器中实际数据的个数。
vec.begin() 返回指向容器第一个元素的迭代器
vec.end() 返回指向容器最后一个元素的迭代器

Vector的简单实现：

#include<iostream>
#include<stdlib.h>
#include<assert.h>
using namespace std;

template<class T>
class Vector
{
public:
    typedef T* Iterator;
    typedef const T* ConstIterator;
    Vector()
        :_start(NULL)
        , _finish(NULL)
        , _endofstorage(NULL)
    {}
    Iterator Begin()
    {
        return _start;//第一个元素的位置
    }
    Iterator End()
    {
        return _finish;//最后一个元素的下一个位置
    }
    size_t Size()
    {
        return _finish - _start;
    }
    size_t Capacity()
    {
        return _endofstorage - _start;
    }

    void PushBack(const T& x)
    {
        Iterator end = End();
        Insert(end, x);
    }
    void PopBack()
    {
        assert(Size() > 0);
        Erase(End());
    }
    void Insert(Iterator pos, const T& x)
    {
        size_t n = pos - _start;
        //插入前应该先检查容量
        if (_finish == _endofstorage)
        {
            size_t len = Size() == 0 ? 2 : 2 * Capacity();
            Expand(len);
        }
        pos = _start + n;
        //把pos位置之后的数据往后挪
        for (Iterator end = End(); end != pos; --end)
        {
            *(end) = *(end - 1);
        }
        *pos = x;
        ++_finish;
    }
    void Erase(Iterator pos)
    {
        //防御式编程，先要判断所给位置是否合法
        assert(pos != NULL);
        //把pos之后的数据往前挪
        for (Iterator end = pos; end < End(); ++end)
        {
            _start[end - _start] = _start[(end + 1) - _start];
        }
        --_finish;
    }
    void Expand(size_t n)
    {
        size_t size = Size();
        size_t capacity = Capacity();
        //当需要的空间大于容量的时候，扩容并拷贝内容
        if (n > capacity)
        {
            //vector是一个可以存放任意类型的动态数组,所以这里在扩容的时候开辟的是数组
            T* ret = new T[n];
            for (size_t i = 0; i < Size(); ++i)
            {
                ret[i] = _start[i];
            }
            delete[] _start;
            //改变数组的指向和容量大小
            _start = ret;
            _finish = _start + size;
            _endofstorage = _start + n;
        }
    }
    void Resize(const size_t n, const T& val = T())
    {
        //当要扩充的容量小于数组的元素个数时，只改变_finish的位置，不改变_capacity的位置
        if (n < Size())
        {
            _finish=_start - n;
        }
        //当要扩充的容量大于数组的元素个数时，增容之后，没有数据的位要进行初始化
        else
        {
            Expand(n);
            size_t size = n - Size();
            for (size_t i = 0; i < size; ++i)
            {
                PushBack(val);
            }
        }
    }
    void Reverse(const size_t n)
    {
        //只扩容然后进行依次赋值，不进行初始化
        Expand(n);
    }
    T& operator[](size_t pos)
    {
        assert(pos < Size());
        return _start[pos];
    }
    const T& operator[](size_t pos)const
    {
        assert(pos < Size());
        return _start[pos];
    }
    void Print()
    {
        for (size_t i = 0; i < Size(); ++i)
        {
            cout << _start[i] << " ";
        }
        cout << endl;
    }
protected:
    Iterator _start;//数组的首元素
    Iterator _finish;//数组的元素个数
    Iterator _endofstorage;//数组的容量
};


int main()
{
    Vector<int> p;
    p.PushBack(1);
    p.PushBack(2);
    p.PushBack(3);
    p.PushBack(4);
    p.PushBack(5);
    p.PushBack(6);
    Vector<int>::Iterator pos=p.Begin();
    for (; pos != p.End();)
    {
        cout << *pos << " ";
        ++pos;
    }
    cout << endl;
    p.PopBack();
    p.PopBack();
    Vector<int>::Iterator it=p.Begin();
    p.Erase(it);
    p.Resize(7,0);
    p.Reverse(6);
    p.Print();
    system("pause");
}