Vector的实现

本文模仿STL中的vector，自己实现其基本功能，主要包括：

• 初始化列表形式的初始化 eg. vector<int> v{1,2,3,4,5};
• 构造函数与析构函数，包括赋值构造、移动构造
• 拷贝函数，包括赋值拷贝、移动拷贝
• 基础API函数：
• • resize( ), reserve( ), size( ), empty( )
• • push_back( ), pop_back( ), begin( ), end( )
• • operator 等等

  注意，模板类不建议使用分离编译，感觉C++的模板就是个坑。
  下面直接贴代码：

#ifndef VECTOR_H
#define VECTOR_H
#include <algorithm>
#include <initializer_list>

template <typename Object>
class Vector{
public:
    Vector( std::initializer_list <Object> l) : theSize(l.size())           //初始化列表
    {
        objects = new Object[l.size()+SPARE_CAPACITY];
        auto it = l.begin(); int k=0;
        for( ; it!=l.end(); ++it,++k)
           objects[k] = *it;
    }

    explicit Vector( int initSize = 0 ): theSize(initSize),             //禁止自动转换
        theCapacity{initSize+SPARE_CAPACITY}
    {
    objects = new Object[theCapacity];
    }
    Vector(const Vector& rhs): theSize(rhs.theSize),
        theCapacity(rhs.theCapacity), objects(nullptr){
        objects = new Object[theCapacity];
        for(int k=0; k<theSize; ++k)
           objects[k] = rhs.objects[k];
    }
    Vector& operator = (const Vector & rhs)
    {
        Vector copy = rhs;
        std::swap(*this, copy);
        return *this;
    }
    Vector(Vector && rhs) : theSize(rhs.theSize),
        theCapacity(rhs.theCapacity), objects(rhs.objects)
    {
        rhs.objects = nullptr;
        rhs.theSize = 0;
        rhs.theCapacity = 0;
    }
    Vector & operator = (Vector &&rhs)
    {
        std::swap(theSize, rhs.theSize);
        std::swap(theCapacity, rhs.theCapacity);
        std::swap(objects, rhs.objects);

        return *this;
    }
    ~Vector()
    {
        delete []objects;
    }

    void resize( int newSize)
    {
        if(newSize > theCapacity)
            reserve( newSize*2 );
        theSize = newSize;
    }

    void reserve( int newCapacity)
    {
        if( newCapacity < theSize)
            return;

        Object *newArray = new Object[newCapacity];
        for(int k=0; k<theSize; ++k)
            newArray[k] = std::move(objects[k]);

        theCapacity = newCapacity;
        std::swap(objects, newArray);
        delete []newArray;
    }
    Object & operator [] (int index)
    {
        return objects[index];
    }
    const Object& operator [](int index) const
    {
        return objects[index];
    }

    bool empty() const
    {
        return size()==0;
    }
    int size() const
    {
        return theSize;
    }
    int capacity() const
    {
        return theCapacity;
    }

    void push_back(const Object & x)
    {
        if(theSize == theCapacity)
            reserve(2*theCapacity+1);
        objects[theSize++] = x;
    }
    void push_back(Object && x)
    {
        if(theSize == theCapacity)
            reserve(2*theCapacity+1);
        objects[theSize++] = std::move(x);
    }
    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()];
    }

    static const int SPARE_CAPACITY = 16;
private:
    int theSize;
    int theCapacity;
    Object * objects;
};


#endif // VECTOR_H

main.cpp:

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

using namespace std;

int main(int argc, char *argv[])
{

    Vector<int> v{1,2,3};  //for(int i=0;i<5;++i) v.push_back(i);
    for(auto i:v)
        cout<<i<<" ";
    //cout << "Hello World!" << endl;
    return 0;
}