重写vector类，完成基本功能，不含迭代器

//vector.h

#include<iostream>

#include<string>

using namespace std;

template<typename T>

class vector

{

        class proxy;

        public:

                vector();

                ~vector();

                void push_back(const T&);

                void pop_back();

                proxy operator[](int index);

                int size();

                int capacity();

                void reallocate();  // 重新分配内存，动态扩容

        private:

                T* _elems;  // 指向数组中的第一个元素

                T* _end;    // 指向数组本身之后的元素

                T* _first_free;  // 指向最后一个实际元素之后的那个元素

                class proxy

                {

                        public:

                                proxy(vector<T>& v,int index):_v(v),_index(index){}  

// 这里形参一定要是引用，传本身啊，不然最后_v._elems[_index]就是错的。浅拷贝

                                T& operator=(const int elem);

                                operator T(){  return _v._elems[_index];  }

                        private:

                                vector<T>& _v;  // 这个地方也是引用

                                int _index;

                };

};

// Vector模型                         

//  ______________________________    

// |_|_|_|_|_|____________________|   

// ↑         ↑                   ↑      

// _elems   _first_free            _end

---

//vector.cpp

#include<iostream>

#include"vector.h"

#include<string.h>

using namespace std;

template<typename T>

vector<T>::vector():_elems(new T[1]),_first_free(_elems)

{

        T* tmp = _elems;

        _end = ++tmp;

}

template<typename T>

vector<T>::~vector()

{

        delete _elems;

        _elems = NULL;

}

template<typename T>

int vector<T>::size()

{

        return _first_free-_elems;

}

template<typename T>

int vector<T>::capacity()

{

        return _end-_elems;

}

template<typename T>

void vector<T>::reallocate()

{

        int size = this->size();

        T* tmp = new T[size*2];

        memcpy(tmp,_elems,size*sizeof(T));

        _elems = tmp;

        _first_free = _elems+size;

        _end = (_elems+size*2);

}

template<typename T>

void vector<T>::push_back(const T& elem)

{

        if(this->size()!=this->capacity())

        {

                int i = (_first_free-_elems)/sizeof(T);

                _elems[i] = elem;

                ++_first_free;

        }

        else if(this->size()==this->capacity())

        {

                this->reallocate();

                int i = (_first_free-_elems)/sizeof(T);

                _elems[i] = elem;

                ++_first_free;

        }

}

template<typename T>

void vector<T>::pop_back()

{

        if(this->size()!=0)

                --_first_free;

}

template<typename T>

typename vector<T>::proxy vector<T>::operator[](int index)

{

        return proxy(*this,index);  

     // 嵌套类不传引用这里出作用域释放了，后面的=什么的没错误，但是执行就报错

}

template<typename T>

T& vector<T>::proxy::operator=(const int elem)

{

        _v._elems[_index] = elem;

        return _v._elems[_index];

}