C++ 在项目的向量类中创建动态数组时出错

我遇到了一些错误，一个back函数的内存错误，并且无法通过程序检查的许多测试

我需要让这段代码正常工作，它位于

Vector.cpp

：

#包括
#包括“Vector.h”
使用名称空间std；
void Vector:：grow（）
{
种植者常数=1.6；
容量=容量*种植者；
}
向量：：向量（）
{
容量=块；
n_元素=0；
数据_ptr=新的整数[容量]；
对于（尺寸i=0；i=0和位置<容量）
{
返回数据_ptr[pos]；
}
其他的
{
投掷距离误差（“距离误差”）；
}
}
大小向量：：大小（）常量
{
返回n_元素；
}
布尔向量：：空（）常量
{
如果（n_元素==0）
{
返回true；
}
其他的
{
返回false；
}
}
int&Vector:：运算符[]（大小位置）
{
返回数据_ptr[pos]；
}
void Vector:：push_back（int项）
{
增长（）；
数据ptr[n元素-1]=项目；
}
void Vector:：pop_back（）
{
如果（n元素>=0）
{
--n_elems；
}
其他的
{
投掷距离误差（“距离误差”）；
}
}
无效向量：：擦除（大小位置）
{
如果（位置>=0和位置<容量）
{
用于（尺寸=位置；i<容量；i++）
{
数据_ptr[i]=数据_ptr[i+1]；
}
n_elems--；
}
其他的
{
投掷距离误差（“距离误差”）；
}
}
无效向量：：插入（大小位置，整数项）
{
int moveCount=n_elems-pos；
增长（）；
如果（位置>=0和位置<容量）
{
对于（大小i=n元素；i>=0；i--）
{
数据_ptr[i]=数据_ptr[i-1]；
}
数据ptr[pos]=项目；
n_elems++；
}
其他的
{
投掷距离误差（“距离误差”）；
}
}
void向量：：clear（）
{
n_元素=0；
}
int*Vector:：begin（）
{
如果（n_元素==0）
{
返回空ptr；
}
其他的
{
返回数据\u ptr；
}
}
int*Vector:：end（）
{
如果（n_元素==0）
{
返回空ptr；
}
其他的
{
返回（数据ptr+（n元素-1））；
}
}
布尔向量：：运算符==（常量向量和v）常量
{
布尔标志=真；
对于（尺寸i=0；i

要通过这些测试，这些测试位于名为

testVector.cpp的文件中：

#包括“Vector.h”
#包括“test.h”
#包括
使用名称空间std；
int main（）{
//测试异常
向量v；
抛出（在（0）处，范围错误）；
抛出（v.pop_back（），范围错误）；
抛出（擦除（0），范围错误）；
抛出（前（），范围错误）；
抛出（返回（），范围错误）；
//测试添加一个元素
v、 推回（1）；
测试（v.size（）=1）；
试验（v.at（0）=1）；
测试（v[0]==1）；
测试（v.front（）==1）；
测试（v.back（）==1）；
测试（！v.empty（））；
//再加一个
v、 推回（2）；
测试（v.size（）=2）；
试验（v.at（0）=1）；
试验（v.at（1）=2）；
测试（v[0]==1）；
测试_v（1）=2）；
测试（v.front（）==1）；
测试（v.back（）==2）；
测试（！v.empty（））；
//测试迭代器
自动iter=v.begin（）；
试验（iter==1）；
++iter；
试验（iter==2）；
++iter；
测试（iter==v.end（））；
//测试副本和==
向量v2=v；
测试（v2.size（）=2）；
测试（v2.at（0）==1）；
试验（v2.at（1）=2）；
测试（v2[0]==1）；
测试（v2[1]==2）；
测试（v2.front（）==1）；
测试（v2.back（）==2）；
测试（！v2.empty（））；
试验（v==v2）；
iter=v2.begin（）；
试验（iter==1）；
++iter；
试验（iter==2）；
++iter；
测试（iter==v2.end（））；
//测试作业
向量v3；
v3=v；
测试（v3.size（）=2）；
测试（v3.at（0）==1）；
测试（v3.at（1）==2）；
测试（v3[0]==1）；
测试（v3[1]==2）；
测试（v3.front（）==1）；
测试（v3.back（）==2）；
测试（！v3.empty（））；
//iter=v3.begin（）；
//试验（iter==1）；
//++iter；
//试验（iter==2）；
//++iter；
//测试（iter==v3.end（））；
//测试作业
v[1]=-2；
测试（v.back（）=-2）；
测试（在（1）=-2处的电压）；
测试（v[1]=-2）；
//测试弹回
v、 向后弹出（）；
测试（v.size（）=1）；
测试（v.front（）==1）；
测试（v.back（）==1）；
试验（v.at（0）=1）；
测试（v[0]==1）；
//测试清晰且可靠=
v、 清除（）；
测试（v.size（）=0）；
测试（v.empty（））；
抛出（在（0）处，范围错误）；
抛出（v.pop_back（），范围错误）；
抛出（擦除（0），范围错误）；
抛出（前（），范围错误）；
抛出（返回（），范围错误）；
试验（v！=v2）；
//测试时代
const int GROWER = 1.6;  
capacity = capacity * GROWER; // it will never change

data_ptr = new int[capacity] {}; // value initialization
//for (size_t i = 0; i < capacity; i++)
//{
//    data_ptr[i] = 0;
//}

bool Vector::operator==(const Vector& v) const
{
    // check here if either of vectors is empty, 
    // if both are empty, they are equal?
    // if their capacities are unequal, vectors are not equal. Those are shortcuts

    // capacities are same
    for (size_t i = 0; i < capacity; i++ )
        if (data_ptr[i] != v.data_ptr[i])
           return false;

    return true;
}