Vector 中迭代器的实现（代码）

#pragma once
//迭代器的实现
class MyVector
{
public:
    /** 迭代器 **/
    class Iterator
    {
        friend class MyVector;
    public:
        Iterator(int* pos) :m_pos(pos)
        {
        }
        Iterator& operator++() //前++
        {
            ++m_pos;
            return *this;
        }
        Iterator operator++(int) //后++
        {
            int* posOld = m_pos;
            ++m_pos;
            return Iterator(posOld);
        }
        Iterator& operator--()//前--
        {
            --m_pos;
            return *this;
        }
        Iterator operator--(int)
        {
            int* posOld = m_pos;
            --m_pos;
            return Iterator(posOld);
        }
        bool operator==(Iterator& itr)
        {
            return (m_pos == itr.m_pos);
        }
        bool operator!=(Iterator& itr)
        {
            return !(*this == itr);
        }
        int& operator*()
        {
            return *m_pos;
        }
        int* operator->()
        {
            return m_pos;
        }
    private:
        int* m_pos = nullptr; //元素位置
    };

public:
    Iterator begin(); //返回指向第一个元素的迭代器
    Iterator end();//返回指向最后一个元素后面位置的迭代器

public:
    MyVector();
    ~MyVector();
    MyVector(const MyVector& obj);

public:
    MyVector& operator=(const MyVector& obj);

public:
    /**增加**/
    void push_back(const int& nVal);

    /*
    * 其他:会抛出异常exception
    */
    Iterator intsert(Iterator itr, const int& nVal);

    /* 修改 */
    int& operator[](int nIdx);
    int& at(int nIdx);

    /* 删除 */
    bool erase(Iterator itr);
    void pop_back();


    /* 查询 */
    Iterator find(const int& nVal);


    /* 其它 */
    int size();

private:
    void CheckCapacity(); //检查内存是否足够放入新的数据

private:
    int* m_pData = nullptr; //保存数组元素的缓冲区
    int  m_nCapacity = 0;   //整块内存的大小
    int  m_nSize = 0;       //当前内存中有多少数据

private:
    const int m_nInitialCapacityLen = 8; //初始化内存的大小
};

#include "stdafx.h"
#include "MyVector.h"
#include <exception>
#include <string>
using namespace std;

MyVector::MyVector()
{
    m_pData = new int[m_nInitialCapacityLen];
    m_nCapacity = m_nInitialCapacityLen;
    m_nSize = 0;
}


MyVector::~MyVector()
{
    /*
    * 释放资源
    */
    if (m_pData != nullptr)
    {
        delete[] m_pData;
        m_pData = nullptr;
    }

    m_nSize = 0;
    m_nCapacity = 0;
}

//返回指向第一个元素的迭代器
MyVector::Iterator MyVector::begin()
{
    return Iterator(m_pData);
}

//返回指向最后一个元素后面位置的迭代器
MyVector::Iterator MyVector::end()
{
    return Iterator(m_pData + m_nSize);
}

MyVector::MyVector(const MyVector& obj)
{
    *this = obj;
}

MyVector& MyVector::operator=(const MyVector& obj)
{
    //释放自己
    if (m_pData != nullptr)
    {
        delete[] m_pData;
    }

    //申请新内存
    m_pData = new int[obj.m_nCapacity]; 
    for (int i = 0; i < obj.m_nSize; i++)
    {
        m_pData[i] = obj.m_pData[i];
    }
    m_nSize = obj.m_nSize;
    m_nCapacity = obj.m_nCapacity;

    return *this;
}

/*
增加
*/
void MyVector::push_back(const int& nVal)
{
    //检查内存大小
    CheckCapacity();

    //存入新的数值
    m_pData[m_nSize] = nVal;
    m_nSize++;
}

MyVector::Iterator MyVector::intsert(Iterator itr, const int& nVal)
{
    /*
    *  获取索引值
    */
    int* pos = itr.m_pos;
    int nIdx = pos - m_pData;


    /*
    * 检查索引是否越界
    */
    if (nIdx < 0 || nIdx > m_nSize)
    {
        throw exception("索引越界");
    }

    /*
    * 检查内存大小
    */
    CheckCapacity();

    /*
    * 拷贝数据
    */
    int nSizeOfCopyData = (m_nSize - nIdx)*sizeof(int);   //拷贝的数据的大小
    int* pBeginPos = m_pData + nIdx;        //拷贝数据的起始位置
    int* pEndPos = m_pData + nIdx + 1;   //拷贝数据的目的位置
    memcpy(pEndPos, pBeginPos, nSizeOfCopyData);

    /*
    *  保存新的数据
    */
    m_pData[nIdx] = nVal;
    m_nSize++;

    return Iterator(&m_pData[nIdx]);
}

/*
修改
*/
int& MyVector::operator[](int nIdx)
{    
    /*
     * 检查索引是否越界
     */
    if (nIdx < 0 || nIdx >= m_nSize)
    {
        throw exception("索引越界");
    }

    return m_pData[nIdx];
}
int& MyVector::at(int nIdx)
{   
    /*
     * 检查索引是否越界
     */
    if (nIdx < 0 || nIdx >= m_nSize)
    {
        throw exception("索引越界");
    }


    return m_pData[nIdx];
}

/*
删除
*/
bool MyVector::erase(Iterator itr)
{
    /*
    *  获取索引值
    */
    int* pos = itr.m_pos;
    int nIdx = pos - m_pData;

    /*
    * 检查索引是否越界
    */
    if (nIdx < 0 || nIdx >= m_nSize)
    {
        throw exception("索引越界");
    }

    /*
    * 拷贝数据,覆盖被删除的数据
    */
    int* pBeginPos = m_pData + nIdx + 1; //获取拷贝数据的起始位置
    int* pEndPos = m_pData + nIdx;       //获取拷贝数据的目标位置
    int  nSizeOfCopyData = (m_nSize - nIdx - 1)*sizeof(int); //拷贝的数据大小
    memcpy(pEndPos, pBeginPos, nSizeOfCopyData);

    m_nSize--;
    return true;
}
void MyVector::pop_back()
{
    /*
    * 检查索引是否越界
    */
    if (m_nSize <= 0)
    {
        throw exception("索引越界");
    }

    //删除数据
    m_nSize--;
}

/*
查询
*/
MyVector::Iterator MyVector::find(const int& nVal)
{
    for (int i = 0; i < m_nSize; i++)
    {
        if (nVal == m_pData[i])
        {
            return Iterator(&m_pData[i]);
        }
    }

    return Iterator(nullptr);
}

/*
其它
*/
int MyVector::size()
{
    return m_nSize;
}

//检查内存是否足够放入新的数据
void MyVector::CheckCapacity()
{
    //内存不够,申请新内存
    if (m_nSize >= m_nCapacity)
    {
        int* pData = new int[m_nCapacity * 2];              //申请新内存
        memcpy(pData, m_pData, m_nCapacity * sizeof(int));  //拷贝原来的数据
        delete[] m_pData;   //释放原来的额内存
        m_pData = pData;
        m_nCapacity = m_nCapacity * 2;
    }
}