<泛> STL - vector 模拟实现

 

今天为大家带来一个模拟STL-vector的模板实现代码。

首先看一下测试结果，之后再为大家呈现设计

测试效果

 测试代码

#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 = 0; i < 10; ++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() + 2, v.begin() + 5);
    cout << "STL: 删除区间【2,5）：";
    for (auto i : v)cout << i << " ";
    cout << endl << endl;
    cout << "当前迭代器位置：" << it - v.begin() << endl << endl;
    It = V.erase(V.begin() + 2, V.begin() + 5);
    cout << "my： 删除区间【2,5）：";
    for (auto i : V)cout << i << " ";
    cout << endl << endl;
    cout << "当前迭代器位置：" << It - V.begin() << endl << endl;
    
    it = v.erase(v.begin() + 5);
    cout << "STL: 单点删除【5】 ：";
    for (auto i : v)cout << i << " ";
    cout << endl << endl;
    cout << "当前迭代器位置：" << it - v.begin() << endl << endl;
    It = V.erase(V.begin() + 5);
    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() + 1, v.end() - 3, v.end());
    cout << "STL: 区间插入：【1】处插入【" << v.end() - 3 - 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() + 1, V.end() - 3, V.end());
    cout << "my: 区间插入：【1】处插入【" << V.end() - 3 - 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() + 4, 100);
    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() + 4, 100);
    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() + 3, 5, 99);
    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() + 3, 5, 99);
    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() + 2, v.begin() + 8);
    cout << "新容器v_，用原来的【2,8）设置容器元素内容： ";
    for (auto i : v)cout << i << " ";
    cout << endl << endl;
    myVector<int> V_;
    V_.assign(V.begin() + 2, V.begin() + 8);
    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(5, 10);
    for (auto i : v)cout << i << " ";
    cout << endl << endl;
    cout << "my: assign另一个重载，将原测试容器内容设置为5个10，效果如下：" << endl << endl;
    V.assign(5, 10);
    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(88);
    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(88);
    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 = 0; i < 10; ++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[8] << endl << endl;
    cout << "my: 【8】为：" << V[8] << 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： 0 1 2 3 4 5 6 7 8 9

my： 0 1 2 3 4 5 6 7 8 9

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

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

STL: 当前最大容量为 13

my: 当前最大容量为 13

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

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

STL: 删除区间【2,5）：0 1 5 6 7 8 9

当前迭代器位置：2

my： 删除区间【2,5）：0 1 5 6 7 8 9

当前迭代器位置：2

STL: 单点删除【5】 ：0 1 5 6 7 9

当前迭代器位置：5

my： 单点删除【5】：0 1 5 6 7 9

当前迭代器位置：5

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

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

0 6 7 9 1 5 6 7 9

当前迭代器位置：1

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

0 6 7 9 1 5 6 7 9

当前迭代器位置：1

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

0 6 7 9 100 1 5 6 7 9

当前迭代器位置：4

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

0 6 7 9 100 1 5 6 7 9

当前迭代器位置：4

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

0 6 7 99 99 99 99 99 9 100 1 5 6 7 9

当前迭代器位置：3

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

0 6 7 99 99 99 99 99 9 100 1 5 6 7 9

当前迭代器位置：3

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

assign 测试，效果如下：

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

新容器v_，用原来的【2,8）设置容器元素内容： 0 6 7 99 99 99 99 99 9 100 1 5 6 7 9

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

新容器V_，用原来的【2,8）设置容器元素内容： 0 6 7 99 99 99 99 99 9 100 1 5 6 7 9

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

10 10 10 10 10

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

10 10 10 10 10

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

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

10 10 10 88

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

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

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

10 10 10 88

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

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

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

清空容器,重置为：

STL： 0 1 2 3 4 5 6 7 8 9

my： 0 1 2 3 4 5 6 7 8 9

STL: 【8】为：8

my: 【8】为：8

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

请按任意键继续. . .

 

 template实现代码

 新版本：

因为最近写了myStack，需要基于myVector实现，所以，把myVector重新完善了一下，同时也添加了一些注释，增加了一些功能，优化了一些内容

如下：

#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 + 1];
        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 - 1; 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 - 1; 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 - 1; i >= index; --i)
            pBuff[i + 1] = pBuff[i];
        pBuff[index] = val;
        len++;
        return myIterator(pBuff + index);
        }

public:  //some basic funciotns of vector class

    myVector()
        :len(0),
        maxSize(0),
        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 = 0; 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 = 0; 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 = 0; 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 = 0; 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 = 0; 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 < 0 || index >= len)
            throw "range_out";
        return pBuff[index];
        }

    T front()
        {  //get the first element of vector
        return pBuff[0];
        }

    T back()
        {  //get the last element of vector
        return pBuff[len - 1];
        }    

    const T& back()const
        {
        return pBuff[len - 1];
        }

    void clear()
        { //clear the vector
        if (pBuff)
            delete[] pBuff;
        pBuff = nullptr;
        maxSize = len = 0;
        }

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 >> 1) > 1 ? (maxSize >> 1) : 1);
            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

 

 

旧版本：

#pragma once

template<typename T>
class myVector
{
    size_t len, maxSize;           //当前长度以及最大长度（已开辟）
    T* pBuff;

public:
    struct myIterator
    {
        T* pIt;

        T operator*()              //迭代器解引用
        {
            return *pIt;
        }
        myIterator& operator=(const myIterator& other)
        {
            if (this != &other)
                pIt = other.pIt;
            return *this;
        }
        myIterator operator+(int n)
        {
            myIterator it;
            it.pIt = pIt;
            it.pIt += n;
            return it;
        }
        myIterator operator-(int n)
        {
            return *this + (-n);
        }
        myIterator& operator++()   //前置++
        {
            pIt++;
            return *this;
        }
        bool operator!=(const myIterator& rhs)const
        {
            return pIt != rhs.pIt;
        }
        size_t operator-(const myIterator& rhs)const  //迭代器相减
        {
            return pIt - rhs.pIt;
        }

    };
public:
    myIterator end()
    {
        myIterator it;
        it.pIt = pBuff + len;
        return it;
    }
    myIterator begin()
    {
        myIterator it;
        it.pIt = pBuff;
        return it;
    }
    myIterator erase(const myIterator& first, const myIterator& last)   //区间删除
    {
        int index1 = first.pIt - pBuff;
        int index2 = last.pIt - pBuff;
        for (int x = index1, i = index2; i < len; ++i)
            pBuff[x++] = pBuff[i];                //区间均为前闭后开
        len -= last - first;
        myIterator tIt;
        tIt.pIt = pBuff + index1;
        return tIt;
    }
    myIterator erase(const myIterator& pos)
    {
        int index = pos.pIt - pBuff;
        if (index == len)
            throw "out of range!";
        for (int i = index; i < len - 1; ++i)
            pBuff[i] = pBuff[i + 1];
        len--;
        myIterator tIt;
        tIt.pIt = pBuff + index;
        return tIt;
    }

    myIterator insert(const myIterator& pos, const myIterator& first, const myIterator& last)
    {
        int index = pos.pIt - pBuff;
        int fir = first.pIt - pBuff;
        int n = last - first;
        resize(len + n);
        for (int i = len - n - 1; i >= index; --i)
            pBuff[i + n] = pBuff[i];
        for (int i = index; i < index + n; ++i)
            pBuff[i] = pBuff[n + fir++];
        myIterator it;
        it.pIt = pBuff + index;
        return it;
    }
    myIterator insert(const myIterator& pos, int n, const T& val)
    {
        int index = pos.pIt - pBuff;
        resize(len + n);
        for (int i = len - n - 1; i >= index; --i)         //移动元素
            pBuff[i + n] = pBuff[i];
        for (int i = index; i < index + n; ++i)            //插入元素
            pBuff[i] = val;
        myIterator it;
        it.pIt = pBuff + index;        
        return it;
    }
    myIterator insert(const myIterator& pos, const T&val)
    {
        int index = pos.pIt - pBuff;
        if (len >= maxSize)
        {
            maxSize = maxSize + ((maxSize >> 1)>1 ? (maxSize >> 1) : 1);
            T* tbuff = new T[maxSize];
            memcpy(tbuff, pBuff, sizeof(T)* len);
            if (pBuff)
                delete[] pBuff;
            pBuff = tbuff;
        }
        for (int i = len - 1; i >= index; --i)
            pBuff[i + 1] = pBuff[i];
        pBuff[index] = val;
        len++;
        myIterator it;
        it.pIt = pBuff + index;
        return it;
    }
public:
    myVector(const int, const T&);   //生成一个容器，容器中含有para1个para2元素
    myVector(const int);             //生成大小为para1的容器
    myVector(const myVector&);
    myVector(myIterator first, myIterator last);  //迭代器区间构造
    myVector();                      //default-constructor
    ~myVector();
    void clear();
public:
    size_t size()const;
    bool empty()const;
    size_t capacity()const;          //最大容量

public:
    bool operator==(const myVector&)const;
    bool operator!=(const myVector&)const;
    bool operator<(const myVector&)const;
    bool operator<=(const myVector&)const;
    bool operator>(const myVector&)const;
    bool operator>=(const myVector&)const;
    myVector& operator=(const myVector&);
    T& operator[](const int);                //索引符重载
    const T& operator[](const int)const;
public:
    void swap(const myVector&);
    void assign(const int n, const T& val);  //重置里面的值
    void assign(myIterator first, myIterator last);
    T& at(const int);                        //同索引符，但会检查越界，抛出异常
    T front();                               //返回第一个元素的位置。
    T back();                                //返回最后一个元素的位置
public:
    void push_back(const T&);
    void pop_back();
    void resize(int);                        //重置元素数量
};

template<typename T>
myVector<T>::myVector(int n, const T& val)
{
    len = maxSize = n;
    pBuff = new T[maxSize];
    for (int i = 0; i < len; ++i)
        pBuff[i] = val;
}

template<typename T>
myVector<T>::myVector(int n)
    :len(n),
    maxSize(n),
    pBuff(new T[maxSize])
{ }

template<typename T>
myVector<T>::myVector(myIterator first, myIterator last)
{
    int n = last - first;
    if (n > 0)
    {
        maxSize = len = n;
        pBuff = new T[n];
        for (int i = 0; i < n; ++i)
            pBuff[i] = *(first + i);
    }
}

template<typename T>
myVector<T>::myVector()
    :len(0),
    maxSize(0),
    pBuff(nullptr)
{ }

template<typename T>
myVector<T>::myVector(const myVector& other)
    :len (other.len),
    maxSize (other.maxSize),
    pBuff (nullptr)
{
    if (other.pBuff != nullptr)
    {
        pBuff = new T[maxSize];
        memcpy(pBuff, other.pBuff, sizeof(T)*len);
    }
}

template<typename T>
void myVector<T>::clear()
{
    if (pBuff)
        delete[] pBuff;
    pBuff = nullptr;
    maxSize = len = 0;
}

template<typename T>
myVector<T>::~myVector()
{
    clear();
}

template<typename T>
size_t myVector<T>::size()const
{
    return len;
}

template<typename T>
bool myVector<T>::empty()const
{
    return !len;
}

template<typename T>
size_t myVector<T>::capacity()const
{
    return maxSize;
}

template<typename T>
bool myVector<T>::operator==(const myVector& rhs)const
{
    if (len != rhs.size()) return false;
    for (int i = 0; i < len; ++i)    //如果两者大小一样，那么就判断里面的元素 (可能不需要）
        if (pBuff[i] != rhs[i])
            return false;
    return true;
}

template<typename T>
bool myVector<T>::operator<(const myVector& rhs)const
{
    if (empty())return true;  //如果左操作数为空，则直接返回真
    int n = (len < rhs.size()) ? len : rhs.len;
    for (int i = 0; i < n; ++i)
    {
        if (pBuff[i] < rhs.pBuff[i])return true;
        if (pBuff[i] > rhs.pBuff[i])return false;
    }
    return false;
}

template<typename T>
bool myVector<T>::operator<=(const myVector& rhs)const
{
    return *this<rhs || *this == rhs;
}

template<typename T>
bool myVector<T>::operator>(const myVector& rhs)const
{
    return !(*this <= rhs);
}

template<typename T>
bool myVector<T>::operator>=(const myVector& rhs)const
{
    return !(*this < rhs);
}

template<typename T>
bool myVector<T>::operator!=(const myVector& rhs)const
{
    return !(*this == rhs);
}

template<typename T>
myVector<T>& myVector<T>::operator=(const myVector& rhs)
{
    if (this != &rhs)
    {
        resize(rhs.size());
        for (int i = 0; i < len; ++i)
            pBuff[i] = rhs[i];
    }
    return *this;
}

template<typename T>
void myVector<T>::assign(const int n, const T& val)
{
    *this = myVector(n, val);
}

template<typename T>
void myVector<T>::assign(myIterator first, myIterator last)
{
    *this = myVector(first, last);
}

template<typename T>
T& myVector<T>::at(const int index)
{
    if (index < 0 || index >= len)
        throw "range_out";
    return pBuff[index];
}

template<typename T>
T& myVector<T>::operator[](int index)
{
    return pBuff[index];
}

template<typename T>
const T& myVector<T>::operator[](int index)const
{
    return pBuff[index];
}

template<typename T>
void myVector<T>::swap(const myVector& rhs)
{
    T* tbuff = pBuff;
    size_t tlen = len;
    size_t tmaxsize = maxSize;

    pBuff = rhs.pBuff;
    len = rhs.len;
    maxSize = rhs.maxSize;

    rhs.pBuff = tbuff;
    rhs.len = tlen;
    rhs.maxSize = tmaxsize;
}

template<typename T>
T myVector<T>::front()
{
    return pBuff[0];
}

template<typename T>
T myVector<T>::back()
{
    return pBuff[len - 1];
}

template<typename T>
void myVector<T>::push_back(const T& val)
{
    if (len >= maxSize)
    {
        maxSize = maxSize + ((maxSize >> 1) > 1 ? (maxSize >> 1) : 1);
        T* tbuff = new T[maxSize];
        for (int i = 0; i < len; ++i)
            tbuff[i] = pBuff[i];
        delete[] pBuff;
        pBuff = tbuff;
    }
    pBuff[len++] = val;
}

template<typename T>
void myVector<T>::pop_back()
{
    len--;
}

template<typename T>
void myVector<T>::resize(int n)
{
    if (n >= maxSize)
    {
        maxSize = n;
        T* tbuff = new T[maxSize];
        memcpy(tbuff, pBuff, sizeof(T)*len);
        if (pBuff)
            delete[]  pBuff;
        pBuff = tbuff;
    }
    len = n;
}

 

 有一些功能没有，但是都类似，自己添加就好了。

 

 感谢您的阅读，生活愉快~