Vector——C++實現

　　

　　在學習數據結構的時候，考慮將所有的容器自己實現一遍，可以加深對數據結構的理解，同時需要運用拷貝控制和泛型編程的知識。

　　vector特點：

　　1、占據一塊連續的內存空間；

　　2、內部實現是通過管理了一個指針，只是當內存空間不夠時，會重新分配一塊更大的內存空間，通常是將容量擴大一倍；

　　3、vector對尾部操作很方便，對頭部或者插入都需要O(n)的時間復雜度；

　　采用模板實現泛型類vector，為了支持大多數的編譯器，將實現文件全部放在頭文件中，不采用分離編譯的方式。

 

　　說明：

　　1、只實現了部分函數的功能，但是類似的可以定義其他的函數；

　　2、迭代器只是采用定義為指針的方式，這種方式比較簡單，但是不能實現迭代器完全的功能。不過迭代器的本質也是將這個指針封裝成一個類。在我的另一篇博客里，通過實現了迭代器類來實現List可以參考：http://www.cnblogs.com/liuteng/p/6006533.html

/************************************************************************/
/* 對vector的實現                                                                     */
/************************************************************************/
#ifndef VECTOR_H
#define VECTOR_H

#define  SPACE_CAPACITY 5
namespace stl
{
    template<typename Object>
    class Vector
    {
    public:
        /************************************************************************/
        /*構造函數                                                              
        /************************************************************************/
        explicit Vector(int initsize = 0)                     //選擇Vector初始大小
            :theSize(initsize)
            ,theCapacity(initsize + SPACE_CAPACITY)
        {
            Objects = new Object[theCapacity];        //分配初始空間
        }

        /************************************************************************/
        /*拷貝構造函數*/                                                                      
        /************************************************************************/
        Vector(const Vector& V)
            :theSize(0)
            ,theCapacity(0)
            ,Objects(NULL)
        {
            *this = V;
        }

        /************************************************************************/
        /*析構函數                                                                      */
        /************************************************************************/
        ~Vector()
        {
            delete[ ] Objects;
        }

        /************************************************************************/
        /*重載賦值操作符                                                                      */
        /************************************************************************/
        Vector &operator = (const Vector& ths)                //需要定義成const型嗎？？？？？
        {
            if (this != ths)        //防止與本身發生拷貝
            {
                delete [] Objects;         //銷毀原來的內存空間
                theSize = ths.theSize;
                theCapacity = ths.theCapacity;
                Objects = new Object[theCapacity];  //重新分配內存空間
                //進行深層次的拷貝
                /* Objects = ths.Objects  這是潛層次的拷貝，只拷貝了指針，
                ** 如果原對象的對象發生改變，那么拷貝對象的內容也發生改變*/
                for (int i = 0; i < ths.theSize; ++i)
                {
                    Objects[i] = ths.Objects[i];
                }
            }
            return *this;
        }

        /************************************************************************/
        /* 函數名：resize
        /* 功   能：改變size大小
        /* 說   明：改變theSize的大小，theCapacity大小不變
        /* 時   間：2016.10
        /************************************************************************/
        //resize后新定義的對象會怎樣被賦值？？？？
        void resize(int newSize)
        {
            if (newSize <= theSize)
                return;
            /*如果size大於capacity，則需要重新分配內存空間,內存空間大小是newsize的兩倍*/
            if(newSize > theCapacity)
                reserve(2 * newSize + 1);         //+1是為了保證newsize為0時，為其分配1的空間，有必要嗎？？？
            theSize = newSize;
        }

        /************************************************************************/
        /* 函數名：reserve
        /* 功   能：重新分配內存空間大小
        /* 說   明：改變theCapacity的大小，theSize大小不變
        /* 時   間：2016.10
        /************************************************************************/
        void reserve(int newCapacity)
        {
            if (newCapacity < theSize)
            {
                return;
            }
            /*把原有的內容拷貝到零食數組中*/
            Object * temp = Objects;
            /*為對象重新分配更大的內存空間*/
            Objects = new Object[newCapacity];
            /*把原來的數據拷貝回來,內存空間大小發生變化，但是size沒有變*/
            for (int i = 0;  i < theSize; ++i)
            {
                Objects[i] = temp[i];
            }
            /*釋放原來的空間*/
            delete[] temp;
        }

        /************************************************************************/
        /* 函數名：operate[]
        /* 功   能：重載下標操作符
        /* 說   明：非常量版本
        /* 時   間：2016.10
        /************************************************************************/
        //下標運算符返回的是元素的引用，定義常量版本和非常量版本
        Object& operator[] (int index)
        {
            return Objects[index];       //指針的下標運算
        }

        /************************************************************************/
        /* 函數名：operate[]
        /* 功   能：重載下標操作符
        /* 說   明：常量版本
        /* 時   間：2016.10
        /************************************************************************/
        const Object& operator[] (int index) const
        {
            return Objects[index];
        }

        /************************************************************************/
        /* 函數名：isEmpty
        /* 功   能：判斷Vector是否為空
        /* 說   明：
        /* 時   間：2016.10
        /************************************************************************/
        bool isEmpty() const
        {
            return size() == 0;
        }

        /************************************************************************/
        /* 函數名：size
        /* 功   能：判斷Vector的大小
        /* 說   明：
        /* 時   間：2016.10
        /************************************************************************/
        int size() const
        {
            return theSize;
        }

        /************************************************************************/
        /* 函數名：capacity
        /* 功   能：判斷Vector的capacity大小
        /* 說   明：
        /* 時   間：2016.10
        /************************************************************************/
        int capacity() const
        {
            return theCapacity;
        }

        /************************************************************************/
        /* 函數名：push_back
        /* 功   能：在vector后面壓入一個數據
        /* 說   明：
        /* 時   間：2016.10
        /************************************************************************/
        void push_back(Object obj)
        {
            //判斷capacity的空間是否還有
            if (theSize == theCapacity)
            {
                //如果內存空間不夠，在現有size基礎上擴容一倍
                reserve(2 * theCapacity + 1);
            }
            //size表示元素的總個數，但是下標是從0開始計數，因此下標取不到size
            Objects[theSize++] = obj;
        }

        /************************************************************************/
        /* 函數名：pop_back
        /* 功   能：在vector后面刪除一個數據
        /* 說   明：
        /* 時   間：2016.10
        /************************************************************************/
        void pop_back()
        {
            --theSize;                  //是不是會導致訪問越界后出現的結果不可控的原因？？？？？
        }

        const Object & back() const
        {
            return Objects[size() - 1];
        }

        typedef Object* iterator;
        typedef const Object* const_iterator;

        iterator begin()
        {
            return &Objects[0];
        }

        iterator end()
        {
            return &Objects[size()];
        }

        const_iterator cbegin() const
        {
            return &Objects[0];
        }

        const_iterator cend() const
        {
            return &Objects[size()];
        }

    private:
        int theSize;
        int theCapacity;
        Object* Objects;    //vector內部實際上是管理了一個數組指針,指向首元素的指針
    };
}
#endif