vector源码学习1(未完)

vector:一个存有多个相同对象的集合。
vector和C中的数组的区别在于，vector都是动态的，他的大小可以增加。
vector就是一个类，要实现一个类，就先看看它需要具有什么功能。
1.定义和初始化(vector<> a())
2.添加元素(push_back)
3.其他：empty(),size(),a[n],a1 = a2,

//vector 的源代码摘录 

template <class T , class Alloc = alloc> //默认使用alloc空间适配器
class vector{
public:
    //类别定义 
    typedef T               value_type;
    typedef value_type *    pointer;
    typedef value_type *    iterator;//vector的迭代器就是原生指针
    typedef value_type &    reference;
    typedef size_t          size_type;
    typedef ptrdiff_t       differnence_type;


protected:
    typedef simple_alloc<value_type, Alloc> data_allocator;

    iterator start;//指向第一个元素的指针 
    iterator finish;//指向最后一个元素的指针 
    iterator end_of_storage;//指向空间的最后一个单元 

    void insert_aux(iterator position , const T& x);//插入元素的函数 
    void dellocate()//调用前面空间适配器中的deallocate函数用来释放空间。 
    {
        if(start)
            data_allocator::deallocate(start,end_of_storage - start);   
    }               

    void fill_initialize(size_type n , const T& value)//构造函数的实际操作 
    {
        start = allocate_and_fill(n,value); //申请空间并填入元素 
        finish = start + n;
        end_of_storage = finish;
    }

public:
    iterator begin ()
    {
        return start;
    }
    iterator end()
    {
        return finish;
    }
    size_type size ()
    {
        return size_type( end() - begin() );
    }
    size_type capacity() const
    {
        return size_type(end_of_storage - begin() );
    }
    bool empty () const
    {
        return begin() == end();
    }
    reference operator [] (size_type n)//重载[]运算符 
    {
        return *( begin() + n );
    }

    vector ()//默认构造 
    {
        start = 0;
        finish = 0;
        end_of_storage = 0;
    }
    vector (size_type n , const T& value)
    {
        fill_initialize(n , value);
    }
    vector (int n , const T& value)
    {
        fill_initialize(n , value);
    }
    vector(long n , const T& value)
    {
        fill_initialize(n , value);
    }
    explict vector (size_type n)
    {
        fill_initialize(n , T() );
    }


    ~vector()
    {
        destory(start , finish);//先析构对象 
        deallocate();//后释放内存 
    }   

    reference front ()
    {
        return *begin();
    }
    reference back ()
    {
        return *finish();
    }
    void push_back (const T& x)
    {
        if (finish != end_of_storage )
        {
            construct (finish , x);
            ++finish;
        }
        else
            insert_aux(end() , x);
    }

    void pop_back()
    {
        --finish;
        destroy(finish);
    }

    iterator erase (iterator position)
    {
        if ( position + 1 != end())
        {
            copy(position + 1 , finish , position)
        }
        --finish;
        destroy(finish);
        return position;
    }

    void resize (size_type new_size , const T& x)
    {
        if (new_size < size() )
        {
            erase(begin() + new_size , end() );
        }
        else
        {
            insert ( end() , new_size - size() , x);
        }
    }
    void resize(size_type new_size)
    {
        return (new_size, T());
    }
    void clear()
    {
        erase( begin(), end());
    }
protected:
    iterator allocate_and_fill(size_type n ,const T& x)//申请空间和填入元素的实际操作 
    {
        iterator result = data_allocator::allocate(n);
        uninitialized_fill_n( result , n , x);
        return result;
    }
};