C++实现vector

c++实现vector

申明：本人的vector并非按照STL的内部实现机制实现的，但实现了vector的大部分功能，算是一种对STL的学习吧~

1.实现的功能

• 实现了vector的所有类型的构造函数
• 重载operator =,[]
• 支持iterator迭代器（可使用ranged for loop)
• 功能函数实现
  
  • erase()
  • push_back()
  • pop_back()
  • clear()
  • begin()
  • end()
  • at()
  • empty()
  • Swap()

2.代码实现

注：以下为.h

#include<iostream>
#include<cstdlib>
using namespace std;
template<class elemtype>
class Vector{
    typedef elemtype* value_pointer;
    typedef elemtype* value_iterator;
    public:
        //constructor and destructor
        Vector();           //default constructor
        Vector(const size_t _Size);
        Vector(const size_t _Size,const elemtype _value);
        Vector(value_pointer _begin,const value_pointer _end);
        Vector(const Vector& _vector);              //copy constructor
        ~Vector();

        //operator
        Vector& operator=(const Vector& _vector);
        elemtype& operator[](const size_t _num)const{return value_data[_num];}
        elemtype& operator[](const size_t _num){return value_data[_num];}           //overload operator[] for const this

        //get the member variable
        size_t size()const{return Size;}
        size_t capacity()const{return Capacity;}

        //the Vector main functions
        void erase();
        void push_back(const elemtype _value);
        void pop_back();
        void clear();
        value_iterator& begin(){return myBegin;}
        value_iterator& end(){return myEnd;}
        elemtype& at(const size_t _num);
        bool empty()const{return size==0;}
        void Swap(const size_t pos1,const size_t pos2);

        void display(); 

    protected:
        void resize();
        value_iterator myBegin;
        value_iterator myEnd;   

    private:
        elemtype* value_data;
        size_t Capacity;                //the Capacity is doubled when less than Size
        size_t Size;
};

template<class elemtype>
Vector<elemtype>::Vector():
    Capacity(0),Size(0),value_data(NULL),
    myBegin(NULL),myEnd(NULL)
{
}

template<class elemtype>
Vector<elemtype>::Vector(const size_t _Size):
    Capacity(2*_Size),Size(_Size)
{
    value_data=(elemtype*)malloc(2*Size*sizeof(elemtype));
    myBegin=value_data;
    myEnd=value_data+Size;
}

template<class elemtype>
Vector<elemtype>::Vector(const size_t _Size,const elemtype _value):
    Capacity(2*_Size),Size(_Size)
{
    value_data=(elemtype*)malloc(2*Size*sizeof(elemtype));
    myBegin=value_data;
    myEnd=value_data+Size;
    for(int i=0;i<Size;i++)
    {
        value_data[i]=_value;
    }
}

template<class elemtype>
Vector<elemtype>::Vector(const Vector& _vector):
    Capacity(_vector.Capacity),Size(_vector.Size)
{
    value_data=(elemtype*)malloc(Capacity*sizeof(capacity));
    memcpy(value_data,_vector.value_data,sizeof(elemtype)*Size);        //copy the data from _vector
    myBegin=value_data;
    myEnd=value_data+Size;
}

template<class elemtype>
Vector<elemtype>::Vector(value_pointer _begin,const value_pointer _end)
{
    Size=_end-_begin;
    Capacity=Size*2;
    value_data=(elemtype*)malloc(Capacity*sizeof(elemtype));
    myBegin=value_data;
    myEnd=value_data+Size;
    memcpy(value_data,_begin,Size*sizeof(elemtype));
}

template<class elemtype>
Vector<elemtype>::~Vector()
{
    Size=0;
    Capacity=0;
    delete value_data;
    value_data=NULL;
    myBegin=NULL;
    myEnd=NULL;
}

template<class elemtype>
void Vector<elemtype>::display()
{
    cout<<"\nthis is the data of the whole vector"<<endl;
    for(int i=0;i<Size;i++)
    {
        cout<<value_data[i]<<endl;
    }
    cout<<"display is end\n"<<endl;
    cout<<endl;
}

template<class elemtype>
Vector<elemtype>& Vector<elemtype>::operator=(const Vector& _vector)
{
    Capacity=_vector.Capacity;
    Size=_vector.Size;
    value_data=(elemtype*)malloc(Capacity);
    myBegin=_vector.value_data;
    myEnd=_vector.value_data+Size;
    memcpy(value_data,_vector.value_data,sizeof(elemtype)*Size);        //copy the data from _vector
    return *this;                                                       //  need this or not???
}

template<class elemtype>
void Vector<elemtype>::erase()
{
    memmove(value_data,value_data+1,(Size)*sizeof(elemtype));
    myEnd--;
    Size--;
}

template<class elemtype>
void Vector<elemtype>::push_back(const elemtype _value)
{
    if(Size+1>Capacity)
    {
        this->resize();
    }
    value_data[Size++]=_value;
    myEnd++;
}

template<class elemtype>
void Vector<elemtype>::pop_back()
{
    value_data[--Size]=NULL;
    myEnd--;
}

template<class elemtype>
void Vector<elemtype>::resize()
{
    if(Capacity==0){Capacity=1;}
    if(!realloc(value_data,sizeof(elemtype)*Capacity*2)==NULL)
    {
    }
    else                //malloc memory manually
    {
        elemtype* index=(elemtype*)malloc(sizeof(elemtype)*Capacity*2);
        memcpy(index,value_data,sizeof(elemtype)*Size);
        delete value_data;
        value_data=index;
        myBegin=value_data;
    }
    Capacity*=2;
}

template<class elemtype>
void Vector<elemtype>::clear()
{
    delete value_data;
    value_data=NULL;
    myBegin=NULL;
    myEnd=NULL;
    Capacity=0;
    Size=0;
}

template<class elemtype>
void Vector<elemtype>::Swap(const size_t _pos1,const size_t _pos2)
{
    elemtype index=value_data[_pos1];
    value_data[_pos1]=value_data[_pos2];
    value_data[_pos2]=index; 
}

template<class elemtype>
elemtype& Vector<elemtype>::at(const size_t _num)
{
    if(_num>Size)
    {
        cerr<<"terminate called after throwing an instance of 'std::out_of_range'"<<endl;
        cerr<<"[VECTOR ERROR] "<<" Invalid index "<<_num<<endl;
        exit(-1);
    } 
    else
    {
        return value_data[_num];
    }
}