#include<iostream>

#include<vector>

#include"myVector.h"

using namespace std;

int main(int argc, char* argv[])

{

    vector<int>v;

    vector<int>::iterator it, it2, it3;

    myVector<int>V;

    myVector<int>::myIterator It, It2, It3;

    //push_back  测试

    for (int i = ; i < ; ++i)

        v.push_back(i), V.push_back(i);

    cout << endl << "push_back 模拟测试，以及对C++11的《基于范围的for循环》进行兼容,效果如下：" << endl << endl;

    cout << "STL： ";

    for (auto i : v)cout << i << " ";

    cout << endl << endl;

    cout << "my： ";

    for (auto i : V)cout << i << " ";

    cout << endl << endl;

    cout << "*--------------------------------------------------------------------------------------------*" << endl << endl;

    cout << "容器的容量增长规律检测,效果如下：" << endl << endl;

    cout << "STL: 当前最大容量为 " << v.capacity() << endl << endl;

    cout << "my: 当前最大容量为 " << V.capacity() << endl << endl;

    cout << "*-----------------------------------------------------------------------------------------------*" << endl << endl;

    //erase 测试   迭代器 + 测试  begin()  end()函数测试

    cout << "erase 测试、迭代器的运算测试，以及begin()、end()函数测试,效果如下" << endl << endl;

    it = v.erase(v.begin() + , v.begin() + );

    cout << "STL: 删除区间【2,5）：";

    for (auto i : v)cout << i << " ";

    cout << endl << endl;

    cout << "当前迭代器位置：" << it - v.begin() << endl << endl;

    It = V.erase(V.begin() + , V.begin() + );

    cout << "my： 删除区间【2,5）：";

    for (auto i : V)cout << i << " ";

    cout << endl << endl;

    cout << "当前迭代器位置：" << It - V.begin() << endl << endl;

    it = v.erase(v.begin() + );

    cout << "STL: 单点删除【5】 ：";

    for (auto i : v)cout << i << " ";

    cout << endl << endl;

    cout << "当前迭代器位置：" << it - v.begin() << endl << endl;

    It = V.erase(V.begin() + );

    cout << "my： 单点删除【5】：";

    for (auto i : V)cout << i << " ";

    cout << endl << endl;

    cout << "当前迭代器位置：" << It - V.begin() << endl << endl;

    cout << "*-----------------------------------------------------------------------------------------------*" << endl << endl;

    //insert测试

    it = v.insert(v.begin() + , v.end() - , v.end());

    cout << "STL: 区间插入：【1】处插入【" << v.end() -  - v.begin() << "," << v.end() - v.begin() << ")：,效果如下：" << endl << endl;

    for (auto i : v)cout << i << " ";

    cout << endl << endl;

    cout << "当前迭代器位置：" << it - v.begin() << endl << endl;

    It = V.insert(V.begin() + , V.end() - , V.end());

    cout << "my: 区间插入：【1】处插入【" << V.end() -  - V.begin() << "," << V.end() - V.begin() << ")：,效果如下：" << endl << endl;

    for (auto i : V)cout << i << " ";

    cout << endl << endl;

    cout << "当前迭代器位置：" << It - V.begin() << endl << endl;

    it = v.insert(v.begin() + , );

    cout << "STL: 单点插入：【4】处插入100，效果如下：" << endl << endl;

    for (auto i : v)cout << i << " ";

    cout << endl << endl;

    cout << "当前迭代器位置：" << it - v.begin() << endl << endl;

    It = V.insert(V.begin() + , );

    cout<<"my: 单点插入：【4】处插入100，效果如下：" << endl << endl;

    for (auto i : V)cout << i << " ";

    cout << endl << endl;

    cout << "当前迭代器位置：" << It - V.begin() << endl << endl;

    it = v.insert(v.begin() + , , );

    cout << "STL: 单点插入：【3】处插入5个99，效果如下：" << endl << endl;

    for (auto i : v)cout << i << " ";

    cout << endl << endl;

    cout << "当前迭代器位置：" << it - v.begin() << endl << endl;

    It = V.insert(V.begin() + , , );

    cout << "my: 单点插入：【3】处插入5个99，效果如下：" << endl << endl;

    for (auto i : V)cout << i << " ";

    cout << endl << endl;

    cout << "当前迭代器位置：" << It - V.begin() << endl << endl;

    cout << "*-----------------------------------------------------------------------------------------------*" << endl << endl;

    //assign 测试

    cout << "assign 测试，效果如下：" << endl << endl;

    cout << "STL: assign区间参数重载，用原来的vector区间设置新的vector，效果如下：" << endl << endl;

    vector<int> v_;

    v_.assign(v.begin() + , v.begin() + );

    cout << "新容器v_，用原来的【2,8）设置容器元素内容： ";

    for (auto i : v)cout << i << " ";

    cout << endl << endl;

    myVector<int> V_;

    V_.assign(V.begin() + , V.begin() + );

    cout << "my: assign区间参数重载，用原来的vector区间设置新的vector，效果如下：" << endl << endl;

    cout << "新容器V_，用原来的【2,8）设置容器元素内容： ";

    for (auto i : V)cout << i << " ";

    cout << endl << endl;

    cout << "STL: assign另一个重载，将原测试容器内容设置为5个10，效果如下：" << endl << endl;

    v.assign(, );

    for (auto i : v)cout << i << " ";

    cout << endl << endl;

    cout << "my: assign另一个重载，将原测试容器内容设置为5个10，效果如下：" << endl << endl;

    V.assign(, );

    for (auto i : V)cout << i << " ";

    cout << endl << endl;

    cout << "*-----------------------------------------------------------------------------------------------*" << endl << endl;

    //pop 测试

    cout << "STL: 弹出最后两个元素，然后push一个88，效果如下：" << endl << endl;

    v.pop_back(), v.pop_back(), v.push_back();

    for (auto i : v)cout << i << " ";

    cout << endl << endl;

    cout << "front()求取容器的第一个元素为：" << v.front() << endl << endl;

    cout << "back()求取容器的最后一个元素为：" << v.back() << endl << endl;

    cout << "my: 弹出最后两个元素，然后插入push一个88，效果如下：" << endl << endl;

    V.pop_back(), V.pop_back(), V.push_back();

    for (auto i : V)cout << i << " ";

    cout << endl << endl;

    cout << "front()求取容器的第一个元素为：" << V.front() << endl << endl;

    cout << "back()求取容器的最后一个元素为：" << V.back() << endl << endl;

    cout << "*-----------------------------------------------------------------------------------------------*" << endl << endl;

    //索引操作

    cout << "清空容器,重置为：" << endl << endl;

    v.clear(), V.clear();

    for (int i = ; i < ; ++i)

        v.push_back(i), V.push_back(i);

    cout << "STL： ";

    for (auto i : v)cout << i << " ";

    cout << endl << endl;

    cout << "my： ";

    for (auto i : V)cout << i << " ";

    cout << endl << endl;

    cout << "STL: 【8】为：" << v[] << endl << endl;

    cout << "my: 【8】为：" << V[] << endl << endl;

//    cout << "my: at(12)为：" << V.at(12) << endl << endl;     //两者同样抛出错误

//    cout << "STL: at(12)为：" << v.at(12) << endl << endl;

    cout << "*-------------------------------------------- E N D --------------------------------------------*" << endl << endl;

}

push_back 模拟测试，以及对C++11的《基于范围的for循环》进行兼容,效果如下：

STL：          

my：          

*--------------------------------------------------------------------------------------------*

容器的容量增长规律检测,效果如下：

STL: 当前最大容量为 

my: 当前最大容量为 

*-----------------------------------------------------------------------------------------------*

erase 测试、迭代器的运算测试，以及begin()、end()函数测试,效果如下

STL: 删除区间【,）：      

当前迭代器位置：

my： 删除区间【,）：      

当前迭代器位置：2

STL: 单点删除【】 ：     

当前迭代器位置：

my： 单点删除【】：     

当前迭代器位置：

*-----------------------------------------------------------------------------------------------*

STL: 区间插入：【】处插入【,)：,效果如下：

当前迭代器位置：

my: 区间插入：【】处插入【,)：,效果如下：

当前迭代器位置：

STL: 单点插入：【】处插入100，效果如下：

当前迭代器位置：

my: 单点插入：【】处插入100，效果如下：

当前迭代器位置：

STL: 单点插入：【】处插入5个99，效果如下：

当前迭代器位置：

my: 单点插入：【】处插入5个99，效果如下：

当前迭代器位置：

*-----------------------------------------------------------------------------------------------*

assign 测试，效果如下：

STL: assign区间参数重载，用原来的vector区间设置新的vector，效果如下：

新容器v_，用原来的【,）设置容器元素内容：               

my: assign区间参数重载，用原来的vector区间设置新的vector，效果如下：

新容器V_，用原来的【,）设置容器元素内容：               

STL: assign另一个重载，将原测试容器内容设置为5个10，效果如下：

my: assign另一个重载，将原测试容器内容设置为5个10，效果如下：

*-----------------------------------------------------------------------------------------------*

STL: 弹出最后两个元素，然后push一个88，效果如下：

front()求取容器的第一个元素为：

back()求取容器的最后一个元素为：

my: 弹出最后两个元素，然后插入push一个88，效果如下：

front()求取容器的第一个元素为：

back()求取容器的最后一个元素为：

*-----------------------------------------------------------------------------------------------*

清空容器,重置为：

STL：          

my：          

STL: 【】为：

my: 【】为：

*-------------------------------------------- E N D --------------------------------------------*

请按任意键继续. . .

#ifndef _MY_VECTOR

#define _MY_VECTOR

template<class T>

    class myVector

    {

public:  //public the date-type information used by class design

    typedef myVector<T> _Mytype;

    typedef size_t size_type;

    typedef T value_type;

    typedef T* _pointer;

#define self (*this)

public:

    struct myIterator

        {

        _pointer pIt;

        myIterator(const _pointer p = nullptr)

            :pIt(p)

            {

            }

        T operator*()

            {  //迭代器解引用

            return *pIt;

            }

        myIterator& operator=(const myIterator& other)

            {  //迭代器赋值

            if (this != &other)

                pIt = other.pIt;

            return self;

            }

        myIterator operator+(int n)

            {  //迭代器移动,不改变原值

            return myIterator(pIt + n);

            }

        myIterator operator-(int n)

            {

            return self + (-n);

            }

        myIterator& operator++()

            {  //迭代器 前置++

            pIt++;

            return self;

            }

        myIterator operator++(int)

            {  //后置++

            myIterator t(self);

            self.pIt++;

            return t;

            }

        bool operator!=(const myIterator& rhs)const

            {

            return pIt != rhs.pIt;

            }

        int operator-(const myIterator& rhs)const

            {  //迭代器作差

            return pIt - rhs.pIt;

            }

        };

public:   //迭代器相关函数

    myIterator end()

        {  //取逾尾指针

        return myIterator(pBuff + len);

        }

    myIterator begin()

        {

        return myIterator(pBuff);

        }

    myIterator erase(const myIterator& first, const myIterator& last)

        //@brief erase 【first,last)

        //@retur the new Iterator of first position

        {

        int from{ first.pIt - pBuff };

        int to{ last.pIt - pBuff };

        for (int i = from; to < len; ++to)

            pBuff[i++] = pBuff[to];

        len -= last - first;

        return myIterator(pBuff + from);

        }

    myIterator erase(const myIterator& pos)

        //@brief erase the value of pos position

        //@retur the new Iterator of pos position

        {

        int index{ pos.pIt - pBuff };

        if (index == len)

            throw "out of range!";

        for (int i = index; i < len; ++i)

            pBuff[i] = pBuff[i + ];

        len--;

        return myIterator(pBuff + index);

        }

    myIterator insert(const myIterator& pos, const myIterator& first, const myIterator& last)

        //@brief insert [first,last) into pos position

        //@retur the new Iterator of pos position

        {

        int index{ pos.pIt - pBuff };

        int from{ first.pIt - pBuff };

        int n{ last - first };

        resize(len + n);

        for (int i = len - n - ; i >= index; --i)

            pBuff[i + n] = pBuff[i];

        for (int i = index; i < index + n; ++i)

            pBuff[i] = pBuff[n + from++];

        return myIterator(pBuff + index);

        }

    myIterator insert(const myIterator& pos, size_type n, const T& val)

        //@brief insert n vals into pos position

        //@retur the new iterator of pos position

        {

        int index{ pos.pIt - pBuff };

        resize(len + n);

        for (int i = len - n - ; i >= index; --i)

            pBuff[i + n] = pBuff[i];

        for (int i = index; i < index + n; ++i)

            pBuff[i] = val;

        return myIterator(pBuff + index);

        }

    myIterator insert(const myIterator& pos, const T& val)

        //@brief insert the val into pos position

        //@retur the new Iterator of pos position

        {

        int index{ pos.pIt - pBuff };

        _Check();

        for (int i = len - ; i >= index; --i)

            pBuff[i + ] = pBuff[i];

        pBuff[index] = val;

        len++;

        return myIterator(pBuff + index);

        }

public:  //some basic funciotns of vector class

    myVector()

        :len(),

        maxSize(),

        pBuff(nullptr)

        { //null vector

        }

    myVector(const size_type n, const T& val)

        :len(n)

        ,maxSize(n)

        ,pBuff(new T[maxSize])

        {  // construct a vector with n vals

        for (int i = ; i < len; ++i)

            pBuff[i] = val;

        }

    myVector(const size_type n)

        :len(n)

        ,maxSize(n)

        ,pBuff(new T[maxSize])

        { // construct a vector which contains n elements

        }

    myVector(myIterator first, myIterator last)

        :len(last - first)

        , maxSize(len)

        , pBuff(new T[len])

        {

        for (int i = ; first != last; ++first, ++i)

            pBuff[i] = *first;

        }

    myVector(const _Mytype& other)

        :len(other.len)

        ,maxSize(other.maxSize)

        ,pBuff(nullptr)

        {

        if (other.pBuff != nullptr)

            {

            pBuff = new T[maxSize];

            memcpy(pBuff, other.pBuff, sizeof(T)*len);

            }

        }

    ~myVector()

        {

        clear();

        }

public:

    size_type size()const

        {  //the number of vector's elements

        return len;

        }

    bool empty()const

        {  //weather vector is null or not

        return !len;

        }

    size_type capacity()const

        {  //the capacity of vector

        return maxSize;

        }

public:  // the operator-loading functions of vector

    bool operator==(const _Mytype& rhs)const

        {

        if (len != rhs.size()) return false;

        for (int i = ; i < len; ++i)

            if (pBuff[i] != rhs[i])

                return false;

        return true;

        }

    bool operator!=(const _Mytype& rhs)const

        {

        return !(self == rhs);

        }

    bool operator<(const _Mytype& rhs)const

        {

        if (empty())return true;

        size_type n = (len < rhs.size()) ? len : rhs.len;

        for (int i = ; i < n; ++i)

            {

            if (pBuff[i] < rhs.pBuff[i])return true;

            if (pBuff[i] > rhs.pBuff[i])return false;

            }

        return false;

        }

    bool operator<=(const _Mytype& rhs)const

        {

        return self < rhs || self == rhs;

        }

    bool operator>(const _Mytype& rhs)const

        {

        return !(self <= rhs);

        }

    bool operator>=(const _Mytype& rhs)const

        {

        return !(self < rhs);

        }

    _Mytype& operator=(const _Mytype& rhs)

        {

        if (this != &rhs)

            {

            resize(rhs.size());

            for (int i = ; i < len; ++i)

                pBuff[i] = rhs[i];

            }

        return self;

        }

    T& operator[](const size_type index)

        {

        return pBuff[index];

        }

    const T& operator[](const size_type index)const

        {

        return pBuff[index];

        }

public:  //the main option of vector

    void push_back(const T& val)

        {

        _Check();

        pBuff[len++] = val;

        }    

    void pop_back()

        {  //erase the last value of vector

        len--;

        }

    void resize(const size_type n)

        {  //reset the number of vector's elements

        if (n >= maxSize)

            {

            maxSize = n;

            _pointer tbuff = new T[maxSize];

            memcpy(tbuff, pBuff, sizeof(T)*len);

            if (pBuff)

                delete[]  pBuff;

            pBuff = tbuff;

            }

        len = n;

        }

    void swap(_Mytype& rhs)

        {   //交互两个vector

        _pointer tbuff = pBuff;

        size_type tlen = len;

        size_type tmaxsize = maxSize;

        //上述三行代码不能用构造函数代替，即：不可以myVerter t(self)

        pBuff = rhs.pBuff;

        len = rhs.len;

        maxSize = rhs.maxSize;

        rhs.pBuff = tbuff;

        rhs.len = tlen;

        rhs.maxSize = tmaxsize;

        }

    void assign(const size_type n, const T& val)

        { //reset the vector

        self = myVector(n, val);

        }

    void assign(myIterator first, myIterator last)

        {  //reset tje vector

        self = myVector(first, last);

        }

    T& at(const size_type index)

        {  //the element of index position

        if (index <  || index >= len)

            throw "range_out";

        return pBuff[index];

        }

    T front()

        {  //get the first element of vector

        return pBuff[];

        }

    T back()

        {  //get the last element of vector

        return pBuff[len - ];

        }    

    const T& back()const

        {

        return pBuff[len - ];

        }

    void clear()

        { //clear the vector

        if (pBuff)

            delete[] pBuff;

        pBuff = nullptr;

        maxSize = len = ;

        }

private:

    size_type len, maxSize;           //当前长度以及最大长度（已开辟）

    T* pBuff;

    void _Check()

        //@brief Guarantee the relationship between len and maxSize is correct

        //@notice if len>=maxSize maxSize += maxSize / 2

        {

        while (len >= maxSize)

            {

            maxSize = maxSize + ((maxSize >> ) >  ? (maxSize >> ) : );

            T* tbuff = new T[maxSize];

            memcpy(tbuff, pBuff, sizeof(T)*len);

            if (pBuff)

                delete[]  pBuff;

            pBuff = tbuff;

            }

        }

    };

template<typename T>

void swap(myVector<T>& lhs, myVector<T>& rhs)

    {

    lhs.swap(rhs);

    }

#endif