C++自己实现一个简单地Vector

直接贴代码

Vector.h

#ifndef __LeetCode__Vector__
#define __LeetCode__Vector__

#include<iostream>
#include <string.h>
using namespace std;

typedef int Rank;//
static const int DEFAULT_CAPACITY = 3;
template <typename T> class Vector
{
protected:
    Rank _size;
    int _capacity;
    T* _elem;
    void copyFrom ( T const* A,Rank lo,Rank hi);
    void expand();
    void shrink();
    bool bubble(Rank lo,Rank hi);//掃描交換
    void bubbleSort(Rank lo,Rank hi);
    Rank max ( Rank lo,Rank hi);
    void selectionSort( Rank lo,Rank hi);
    void merge ( Rank lo, Rank mi, Rank hi );
    void mergeSort ( Rank lo,Rank mi ,Rank hi);
    Rank partition ( Rank lo, Rank hi ); //轴点构造算法
    void quickSort ( Rank lo, Rank hi ); //快速排序算法
    void heapSort ( Rank lo, Rank hi ); //堆排序
public:
    Vector(int c = DEFAULT_CAPACITY, int s = 0,T v = 0)//默認構造函數
    {
        _elem = new T[_capacity = c];
        for ( _size = 0; _size < s; _elem[_size++] = v );
    }
    Vector ( T const* A, Rank n ) { copyFrom ( A, 0, n ); } //数组整体复制
    Vector ( T const* A, Rank lo, Rank hi ) { copyFrom ( A, lo, hi ); } //区间
    Vector ( Vector<T> const& V ) { copyFrom ( V._elem, 0, V._size ); } //向量整体复制
    Vector ( Vector<T> const& V, Rank lo, Rank hi ) { copyFrom ( V._elem, lo, hi ); }//向量区间
    ~Vector(){delete [] _elem;}//析構函數
    //只讀
    Rank size() const {return this->_size;}
    bool empty() const {return !_size;}
    int disordered() const;
    Rank find ( T const& e ) const { return find ( e, 0, _size ); } //无序向量整体查找
    Rank find ( T const& e, Rank lo, Rank hi ) const; //无序向量区间查找
    Rank search ( T const& e ) const //有序向量整体查找
    { return ( 0 >= _size ) ? -1 : search ( e, 0, _size ); }
    Rank search ( T const& e, Rank lo, Rank hi ) const; //有序向量区间查找
    // 可写访问接口
    T& operator[] ( Rank r ) const; //重载下标操作符，可以类似于数组形式引用各元素
    Vector<T> & operator= ( Vector<T> const& ); //重载赋值操作符，以便直接克隆向量
    T remove ( Rank r ); //删除秩为r的元素
    int remove ( Rank lo, Rank hi ); //删除秩在区间[lo, hi)之内的元素
    Rank insert ( Rank r, T const& e ); //插入元素
    Rank insert ( T const& e ) { return insert ( _size, e ); } //默认作为末元素插入
    void sort ( Rank lo, Rank hi ); //对[lo, hi)排序
    void sort() { sort ( 0, _size ); } //整体排序
    void unsort ( Rank lo, Rank hi ); //对[lo, hi)置乱
    void unsort() { unsort ( 0, _size ); } //整体置乱
    int deduplicate(); //无序去重
    int uniquify(); //有序去重
    // 遍历
    void traverse ( void (* ) ( T& ) ); //遍历（使用函数指针，只读或局部性修改）
    template <typename VST> void traverse ( VST& ); //遍历（使用函数对象，可全局性修改）
    
};


#endif /* defined(__LeetCode__Vector__) */

Vector.cpp

#include "Vector.h"
template <typename T>//元素类型
void Vector<T>::copyFrom ( T const* A, Rank lo, Rank hi )
    { //以数组区间A[lo, hi)为蓝本复制向量
        _elem = new T[_capacity = 2 * ( hi - lo ) ]; _size = 0; //分配空间，规模清零
        while ( lo < hi ) //A[lo, hi)内的元素逐一
        _elem[_size++] = A[lo++]; //复制至_elem[0, hi - lo)
     }

template <typename T>
void Vector<T>::expand()
{
    if(_size<_capacity) return;
    _capacity = max(_capacity, DEFAULT_CAPACITY);
    T oldeElem = _elem;
    _elem = new T[_capacity <<= 1];
    for (int i = 0; i<_size; i++)
    {
        _elem[i] = oldeElem;
    }
    delete [] oldeElem;
}

template <typename T>
T& Vector<T>::operator[] (Rank r)const {return _elem[r];}

template <typename T>

Rank Vector<T>::insert(Rank r,T const & e)
{
    this->expand();
    for (int i = _size; i > r; i++)
    {
        _elem[i]=_elem[i-1];
    }
    _elem[r]=e;
    _size++;
    return r;
}

template <typename T>
int Vector<T>::remove(Rank lo, Rank hi)
{
    if (lo>hi)
    {
        return 0;
    }
    while (hi < _size)
    {
        _elem[lo++]=_elem[hi++];
    }
    _size =lo;
    this->shrink();
    return hi -lo;
}

template <typename T>
T Vector<T>::remove(Rank r)
{
    T e = _elem[r];
    this->remove(r,r+1);
    return e;
}

template <typename T>
Rank Vector<T>::find(const T &e, Rank lo, Rank hi) const
{
    while ((lo <  hi --) && ( e != _elem[hi]));
    return hi;
}

template <typename T>
int  Vector<T>::deduplicate()
{
    int oldSize = this->_size;
    Rank i = 1;
    while (i < _size)
    {
        find(_elem[i],0,i)? i++ : remove(i);
    }
    return oldSize-_size;
}