【实现vector模板类】

什么是vector

向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。Vectors 包含着一系列连续存储的元素,其行为和数组类似。访问Vector中的任意元素或从末尾添加元素都可以在常量级时间复杂度内完成，而查找特定值的元素所处的位置或是在Vector中插入元素则是线性时间复杂度。

基本函数

    My_vector();                                              //无参构造
    My_vector(int n,const T &value);                          //有参构造,构造并初始化n个值
    ~My_vector();
    My_vector(T* first, T* last);                             //使用迭代器进行初始化
    My_vector(const My_vector<T>& from);                      //拷贝构造
    My_vector<T> &operator=(const My_vector<T> v);            // =重载
    T &at(size_t loc);                                        //返回第loc位置的引用
    T &front();                                               //返回第一个元素
    T &back();                                                //返回最后一个元素
    T* begin();                                               //函数返回一个指向当前vector起始元素的迭代器
    T* end();                                                 // 函数返回一个指向当前vector末尾元素的下一位置的迭代器.
    size_t capacity();                                        //返回vector所能容纳的元素数量(在不重新分配内存的情况下）
    size_t size();                                            //求大小
    void clear();                                             //清楚所有元素
    bool empty();                                             //判空

    T* erase(T* loc);                                         //删除指定元素
    void push_back(const T& value);                           //在Vector最后添加一个元素
    void pop_back();                                          //移除最后一个元素
    T &operator[](int pos);                                   // [] 重载
    void reserve(size_t n);                                    //设置Vector最小的元素容纳数量
    void swap( My_vector<T>& v);                              //交换两个Vector

函数实现

template <class T>
My_vector<T>::My_vector():_first(NULL),_last(NULL),_end(NULL){}

template <class T>
My_vector<T>::My_vector(int n,const T &value):_first(NULL),_last(NULL),_end(NULL)
{
    reserve(n);
    for(int i=0;i<n;i++)
    {
        push_back(value);
    }
}

template <class T>
My_vector<T>::~My_vector()
{
    delete _first;
    _first=_last=_end=NULL;
}

template <class T>
My_vector<T>::My_vector(T* first, T* last):_first(NULL),_last(NULL),_end(NULL)
{
    while (first!=last) {
        push_back(*first);
        ++first;
    }
}

template <class T>
My_vector<T>::My_vector(const My_vector<T>& from)
{
    this->_first=from._first;
    this->_last=from._last;
    this->_end=from._end;
}

template <class T>
My_vector<T> &My_vector<T>::operator=(My_vector<T> v)
{
    swap(v);
    return *this;
}

template <class T>
T& My_vector<T>::at(size_t loc)
{
    static T err;
    if(loc<size()&&loc>=0)
        return _first[loc];
    else
        return err;
}

template <class T>
T& My_vector<T>::back()
{
    return *_last;
}

template <class T>
T& My_vector<T>::front()
{
    return *_first;
}

template <class T>

T* My_vector<T>::begin()
{
    return _first;
}

template <class T>

T* My_vector<T>::end()
{
    return _last;
}

template <class T>
void My_vector<T>::reserve(size_t n)
{
    if(n>capacity())
    {
        size_t s=size();                    //记录原本的大小
        T *temp=new T[n];                   //定义一个空的并申请空间
        memcpy(temp,_first,s*sizeof (T));   //将原本的内容复制到temp中
        delete [] _first;                   //将原本空间释放
        _first=temp;                        
        _last=temp+s;
        _end=temp+n;
    }
}

template <class T>
size_t My_vector<T>::capacity()
{
    return _end-_first;
}

template <class T>
size_t My_vector<T>::size()
{
    return _last-_first;
}

template <class T>
void My_vector<T>::clear()
{
    _last=_first;
}

template <class T>
bool My_vector<T>::empty()
{
    if(_first==_last)
    {
        return true;
    }else
    {
        return false;
    }
}

template <class T>
T* My_vector<T>::erase(T* loc) //erase函数要么删作指定位置loc的元素,返回值是指向删除的最后一个元素的下一位置的迭代器.
{

    if(loc>=_first&&loc<_last)
    {
        T* begin = loc+1;
            while (begin < _last)
            {
                *(begin-1) = *(begin);          //挨个往前移
                ++begin;
            }

            _last--;

            return loc;
    }
    return  NULL;
}

template <class T>
void My_vector<T>::push_back(const T& value)
{
    if (_last == _end)
        {
            size_t newcapacity = capacity() == 0 ? 1: capacity() * 2;   //如果原本为空，设容量为1，如果容量用完，按倍数增加；
            reserve(newcapacity);
        }
        *_last = value;
        ++_last;
}

template <class T>
void My_vector<T>::pop_back()
{
    if(_last>_first)
    {
        _last--;
    }
}

template <class T>
T &My_vector<T>::operator[](const int pos)
{
    return _first[pos];
}

template <class T>
void My_vector<T>:: swap( My_vector<T>& v)              //用到std里的swap函数
{
    std::swap(this->_first,v._first);
    std::swap(this->_last,v._last);
    std::swap(this->_end,v._end);
}

测试函数

int main()
{
    My_vector<int> v1;        //定义一个容器


    cout<<"v1.size = "<<v1.size()<<endl;      //0
    cout<<"v1.capacity = "<<v1.capacity()<<endl;   //0


    cout<<"************************************************************\n";


    for(int i=1; i<=20; i++)
    {
        v1.push_back(i);
        cout<<"v1.size = "<<v1.size()<<"    v1.capacity = "<<v1.capacity()<<endl;
    }

    //输出当前vector中的内容
    for(size_t i=0; i<v1.size(); i++)
    {
        //cout<<v1[i]<<" ";
        cout<<v1.at(i)<<" ";
    }
    cout<<endl;


    //调用尾删函数
    v1.pop_back();
    for(size_t i=0; i<v1.size(); i++)
    {
        //cout<<v1[i]<<" ";
        cout<<v1.at(i)<<" ";
    }
    cout<<endl;


    //将第一个元素的值改为100,最后一个值改为200
    v1.front() = 100;
    v1.back() = 200;
    for(size_t i=0; i<v1.size(); i++)
    {
        //cout<<v1[i]<<" ";
        cout<<v1.at(i)<<" ";
    }
    cout<<endl;


    //使用迭代器来遍历数组
        for(int *p=v1.begin(); p!=v1.end(); p++)    {
            cout<<*p<<" ";
        }
        cout<<endl;


    //清空vector
    v1.clear();
    cout<<"v1.size = "<<v1.size()<<endl;      //0
    cout<<"v1.capacity = "<<v1.capacity()<<endl;


    for(size_t i=0; i<v1.capacity(); i++)
    {
        cout<<v1[i]<<" ";
        //cout<<v1.at(i)<<" ";
    }
    cout<<endl;


    //使用有参构造函数构造一个vector
    My_vector<char> v2(5, 'A');
    for(size_t i=0; i<v2.size(); i++)
    {
        cout<<v2[i]<<" ";
        //cout<<v1.at(i)<<" ";
    }

    cout<<"v2.size = "<<v2.size()<<endl;      //5
    cout<<"v2.capacity = "<<v2.capacity()<<endl;   //5
    v2.push_back('G');
    for(size_t i=0; i<v2.size(); i++)
    {
        cout<<v2[i]<<" ";
        //cout<<v1.at(i)<<" ";
    }
    cout<<"v2.capacity = "<<v2.capacity()<<endl;   //10
    //删除指定元素
    v2.erase(&v2[5]);
    cout<<"删除后 v2.size = "<<v2.size()<<endl;
    for(size_t i=0; i<v2.size(); i++)
    {
        cout<<v2[i]<<" ";
        //cout<<v1.at(i)<<" ";
    }
    cout<<endl;
    //使用别的容器给新容器初始化
    int arr[] = {3,8,4,6,2,9,1,0,7};


    My_vector<int> v3(&arr[0],arr+5);

    for(size_t i=0; i<v3.size(); i++)
    {
        cout<<v3[i]<<" ";
        //cout<<v1.at(i)<<" ";
    }
    return 0;
}

效果演示