2、vector的实现

        看侯捷老师的《STL源码剖析》有一段时间了，打算自己整理一下思路，试着实现一下。主要目的有两个：1、巩固自己对源码的理解，让自己更加深刻的体会其中各种机制的奥妙。别人的知识永远是别人的，只有自己亲自动手实践过，才能转化为自己的。2、通过实现这些优秀的算法，来提高自己的“内功”修养。

        vector其实就是动态数组。它的性质与数组基本一致。同样使用的是一片连续的内存空间。它与数组相比，其优点是灵活性较强，其空间大小可变。但是其效率没有数组高。这是因为受到了其空间配置器的影响。SGI-STL中，为了减少内存碎片，在空间配置方面有很多机制。创建一个vector时，需要分配填充内存池、填充free-list、分配内存等一系列操作。这使得它的效率稍微低了些。此外，当空间不足，需要扩充空间时，SGI-STL采用“三步走”的措施，即：分配新的空间——将原来数据拷贝过去——释放原来的空间。我们在使用时，应该尽量避免扩充vector的空间。还有一点应当注意，当写出如下代码的时候，虽然分配了10个元素的空间，当你紧接着再往容器中添加数据时，同样会扩充空间。也就是程序执行完成第2行代码时，其正在的元素个数已经变成了11，而不是原来的10。其具体原因请看源代码

vector<int> Vec(10);
Vec.push_back(10);

　　以下是我自己根据源代码，仿造的vector。

#ifndef CVECTOR_H_
#define CVECTOR_H_

#include "DefaultAllocTemplate.h"
#include "AllocatorInterface.h"
#include "comm.h"
#include <iterator.h>
#include <new.h>
#include <stdlib.h>
#include <unistd.h>

template <class T, class Alloc = CDefaultAllocTemplate>
class CVector {
/*以下是Vector的迭代器类型*/
public:
    typedef T ValueType;
    typedef ValueType* Pointer;
    typedef ValueType* Iterator;
    typedef ValueType& Reference;
    typedef size_t SizeType;
    typedef ptrdiff_t DifferenceType;
protected:

    /*空间配置器*/
    typedef AllocatorInterface<ValueType,Alloc>DataAllocator;

    /*目前正在使用的空间的头部*/
    Iterator m_Start;

    /*目前正在使用空间的尾部*/
    Iterator m_Finish;

    /*可用空间的尾部，它与m_Start决定了容器的最大容量*/
    Iterator m_EndOfStorage;

    /*向Vetory中插入一个成员*/
    void InsertAux(Iterator Pos, const T& x);

    /*销毁容器*/
    void Deallocate()
    {
        if(0 != m_Start)
        {
            /*调用空间配置器接口中的函数销毁销毁容器*/
            DataAllocator::Deallocate(m_Start, m_EndOfStorage - m_Start);
        }
    }

    /*创建容器，并为其分配存储空间。该函数可以获取uiNum个对象的内存空间，
     *并将内存指针保存在m_Start中。以后的构造函数中，都会调用这个函数*/
    void FillInitialize(SizeType uiNum, const T& Value)
    {
        m_Start = AllocateAndFill(uiNum, Value);
        /*注意，这里会使得原来的你在创建vector的时候，无论你申请了多少个元素的空间，当你（即使是申请后马上）
         *调用PushBack函数时，也会扩大原来的内存空间*/
        m_Finish = m_Start + uiNum;
        m_EndOfStorage = m_Finish;
    }

    /*配置空间并填充内容*/
    Iterator AllocateAndFill(SizeType uiNum, const T& Value)
    {
        Iterator Result=DataAllocator::Allocate(uiNum);
        //调用全局函数为对象配置内存
        uninitialized_fill_n(Result, uiNum, Value);
        return Result;
    }

public:
    /*获取容器起始位置*/
    Iterator Begin()
    {
        return m_Start;
    }

    /*获取容器中正在使用空间的尾部*/
    Iterator End()
    {
        return m_Finish;
    }

    /*返回容器中元素个数*/
    SizeType Size()
    {
        return (SizeType)(m_Finish - m_Start);
    }

    SizeType Capacity()
    {
        return (SizeType)(m_EndOfStorage - m_Start);
    }

    /*判断容器是否为空*/
    int Empty()
    {
        return m_Start == m_Finish;
    }

    /*重载"[]"符号，让容器可以通过下标获取元素*/
    Reference operator[](SizeType uiNum)
    {
        return *(m_Start + uiNum);
    }

    /*无参构造函数，创建一个空的容器*/
    CVector() : m_Start(0), m_Finish(0), m_EndOfStorage(0)
    {
        //这里面本身就不需要任何内容
    }

    /*以下三个构造函数功能一样，都是创建一个可以容纳uiNum个对象的容器。并且会将Value中的数据拷贝uiNum个过去。
     *只是其中的uiNum类型不一样，这里写三个是为了兼容不同的类型*/
    CVector(SizeType uiNum, const T& Value)
    {
        /*这三行是为了消除警告*/
        m_Start = 0;
        m_Finish = 0;
        m_EndOfStorage = 0;

        /*调用函数分配内存空间*/
        FillInitialize(uiNum, Value);
    }

    CVector(int uiNum, const T& Value)
    {
        /*这三行是为了消除警告*/
        m_Start = 0;
        m_Finish = 0;
        m_EndOfStorage = 0;

        /*调用函数分配内存空间*/
        FillInitialize(uiNum, Value);
    }

    CVector(long uiNum, const T& Value)
    {
        /*这三行是为了消除警告*/
        m_Start = 0;
        m_Finish = 0;
        m_EndOfStorage = 0;

        /*调用函数分配内存空间*/
        FillInitialize(uiNum, Value);
    }

    /*创建能容纳uiNum个对象的容器*/
    explicit CVector(long uiNum)
    {
        /*这三行是为了消除警告*/
        m_Start = 0;
        m_Finish = 0;
        m_EndOfStorage = 0;

        /*调用函数分配内存空间，其中的T()将会创建一个临时变量。但是为什么需要这样去创建呢？？
         *为了让该函数能够调用，所以创建一个临时对象*/
        FillInitialize(uiNum, T());
    }

    explicit CVector(int uiNum)
        {
            /*这三行是为了消除警告*/
            m_Start = 0;
            m_Finish = 0;
            m_EndOfStorage = 0;

            /*调用函数分配内存空间，其中的T()将会创建一个临时变量。但是为什么需要这样去创建呢？？
             *为了让该函数能够调用，所以创建一个临时对象*/
            FillInitialize(uiNum, T());
        }

    explicit CVector(SizeType uiNum)
        {
            /*这三行是为了消除警告*/
            m_Start = 0;
            m_Finish = 0;
            m_EndOfStorage = 0;

            /*调用函数分配内存空间，其中的T()将会创建一个临时变量。但是为什么需要这样去创建呢？？
             *为了让该函数能够调用，所以创建一个临时对象*/
            FillInitialize(uiNum, T());
        }

    ~CVector()
    {
        /*一个对象的销毁分为两步完成：
         *1、释放容器的内存空间
         *2、销毁容器*/
        destroy(m_Start, m_EndOfStorage);//释放容器占用的内存空间
        Deallocate();//调用容器中的函数，销毁容器
    }

    /*返回第一个元素*/
    Reference Front()
    {
        return *(m_Start);
    }

    /*返回最后一个元素*/
    Reference Back()
    {
        return *(m_Finish - 1);
    }

    /*向vector的尾部添加一个元素*/
    void PushBack(const T& Element)
    {
        /*判断容器是否已经满了，如果没有满，则直接进行插入。如果满了，则需要调用InsertAux函数，
         *为容器重新分配内存空间*/
        if(m_Finish != m_EndOfStorage)
        {
            construct(m_Finish, Element);
            ++m_Finish;
        }
        else
        {
            InsertAux(End(), Element);
        }
    }

    /*将容器中最后一个元素取出来*/
    void PopBack()
    {
        --m_Finish;
        destory(m_Finish);
    }

    /*清除指定位置的某个元素*/
    Iterator Erase(Iterator Position)
    {
        if(Position + 1 != End())
        {
            copy(Position + 1, m_Finish,  Position);//将后面的数据向前移动
        }
        m_Finish--;
        destroy(m_Finish);//调用全局函数，释放多余的空间
        return Position;
    }

    /*清除指定某区域中的元素*/
    Iterator Erase(Iterator StartPosition, Iterator EndPosition)
    {
        if(EndPosition + 1 != End())
        {
            copy(EndPosition + 1, m_Finish,  StartPosition);//将后面的数据向前移动
        }
        m_Finish -= (StartPosition - EndPosition);    //调整末尾指针
        destroy(m_Finish, StartPosition - EndPosition);//调用全局函数，释放多余的空间
        return StartPosition;
    }

    /*重新为容器分配空间，其大小为uiNewSize，如果新的空间大于原来的空间，
     *则新增加的空间将会以InitialValue作为初值进行初始化；如果新的空间
     *小于原来的空间，将会把多余的数据清除掉*/
    void Resize(SizeType uiNewSize, const T& InitialValue)
    {
        if(uiNewSize < Size())
        {
            Erase(Begin() + uiNewSize, End());//空间过小，清除元素
        }
        else
        {
            insert(End(), uiNewSize - Size(), End());
        }
    }

    /*重新为容器分配空间，其大小为uiNewSize。但是用户可以不进行初始化*/
    void Resize(SizeType uiNewSize)
    {
        Resize(uiNewSize, T());
    }

    /*清空容器中的元素*/
    void Clear()
    {
        Erase(Begin(), End());
    }
};

template <class T, class Alloc>
void CVector<T, Alloc>::InsertAux(Iterator Position, const T& Element)
{
    if(m_Finish != m_EndOfStorage) //还有备用空间
    {
        construct(m_Finish, *(m_Finish - 1));//在备用空间中构造一个
        m_Finish++;//调整备用空间剩余容量
        T ElementCpoy = Element;//将要插入的节点进行拷贝
        /*调用全局函数，为要插入的节点移出一块内存空间*/
        copy_backward(Position, m_Finish - 2, m_Finish - 1);
        *Position = ElementCpoy;//将节点插入
    }
    else//没有备用空间了
    {
        const SizeType uiOldSize = Size();//计算原来空间的长度
        /*得到需要的长度，若原来大小不为零，则新开辟的大小应该为其原本大小的两倍，反之则为1*/
        const SizeType uiLen = uiOldSize != 0 ? 2 * uiOldSize : 1;
        Iterator NewStart = DataAllocator::Allocate(uiLen);//开辟内存并且将新的内存地址保存
        Iterator NewFinish = NewStart;
        try
        {
            /*将vector中的数据拷贝到新的vector内存中*/
            NewFinish = uninitialized_copy(m_Start, Position, NewStart);
            /*为新的元素设定值*/
            construct(NewFinish, Element);
            ++NewFinish;
            /*将备用空间的内容也拷贝过来，这可能没什么用！！*/
            NewFinish = uninitialized_copy(Position, m_Finish, NewFinish);
        }
        catch(...)
        {
            destroy(NewStart, NewFinish);
            DataAllocator::Deallocate(NewStart, uiLen);
            throw;
        }

        destroy(Begin(), End());
        Deallocate();

        m_Start = NewStart;
        m_Finish = NewFinish;
        m_EndOfStorage = NewStart + uiLen;
    }
}

#endif

以上代码更多的是为自己的学习做个笔记，欢迎交流讨论！