C++ 将迭代器与C++；

我已经创建了一个自定义向量，我想为它创建一个迭代器，我已经将代码简化为一个最小版本，只剩下一个错误。我想修复这个错误，然后让代码执行它应该执行的操作，即打印数组元素的总和

代码如下：

#include <iostream>
using namespace std;



template <class Elem>
class ArrayVector{
    public :
        ArrayVector(){
            A = new Elem[3];
            A[0] = 1;
            A[1] = 2;
            A[3] = 3;
            ptr = &A[0];
        }
        const ArrayVector * begin(){
            this->begin();
        }
    class iteratorArray{
            Elem * current;
            const ArrayVector * begin(){
                return iteratorArray();
            }
            const ArrayVector* end(){  
                iteratorArray* end = new iteratorArray(&current[3]);
                return end;
            }
            iteratorArray(Elem* initLoc){
                current = initLoc;
            }
            iteratorArray operator+(int n){
                current = &current[n];
                return *this;
            }
            bool operator!=(iteratorArray& obj2){
                return this->current != obj2.current;
            }
            iteratorArray operator++(){
                current = current+1;
                return *this;
            }
            Elem& operator*(){
                return *current;
            }
    };
    Elem* A;
    Elem* ptr;
};


int main() {
    ArrayVector<int> vector1;
    typedef ArrayVector<int>::iteratorArray iteratorArray;  
    int sum = 0;
    for (iteratorArray p = vector1.begin(); p != vector1.end(); ++p)
        sum += *p;
    return sum;
}

#包括
使用名称空间std；
模板
类ArrayVector{
公众：
ArrayVector（）{
A=新元素[3]；
A[0]=1；
A[1]=2；
A[3]=3；
ptr=&A[0]；
}
常量ArrayVector*开始（）{
这个->开始（）；
}
类迭代器数组{
元素*电流；
常量ArrayVector*开始（）{
返回iteratorArray（）；
}
常量ArrayVector*end（）{
迭代器阵列*end=新的迭代器阵列（&当前[3]）；
返回端；
}
迭代器数组（元素*initLoc）{
电流=初始位置；
}
迭代器数组运算符+（int n）{
当前=&当前[n]；
归还*这个；
}
布尔运算符！=（迭代器数组和obj2）{
返回此->当前！=obj2.current；
}
迭代器数组运算符++（）{
电流=电流+1；
归还*这个；
}
电气和操作员*（）{
返回*当前值；
}
};
元素*A；
元素*ptr；
};
int main（）{
阵列矢量1；
typedef ArrayVector:：iteratorArray iteratorArray；
整数和=0；
for（迭代器数组p=vector1.begin（）；p！=vector1.end（）；++p）
总和+=*p；
回报金额；
}

您实现的

迭代器数组

完全错误。它应该更像这样：

#包括
模板
类ArrayVector{
私人：
元素*A；
公众：
ArrayVector（）{
A=新元素[3]；
A[0]=1；
A[1]=2；
A[2]=3；
}
ArrayVector（常量ArrayVector和src）{
A=新元素[3]；
A[0]=src.A[0]；
A[1]=src.A[1]；
A[2]=src.A[2]；
}
~ArrayVector（）{
删除[]A；
}
ArrayVector和运算符=（常量ArrayVector和rhs）{
A[0]=rhs.A[0]；
A[1]=rhs.A[1]；
A[2]=rhs.A[2]；
归还*这个；
}
类迭代器{
私人：
元素*电流；
公众：
迭代器（Elem*initLoc）{
电流=初始位置；
}
迭代器运算符+（int n）常量{
返回迭代器（当前+n）；
}
迭代器运算符-（int n）常量{
返回迭代器（current-n）；
}
迭代器和运算符++（）{
++电流；
归还*这个；
}
迭代器运算符++（int）{
返回迭代器（当前++）；
}
迭代器和运算符--（）{
--电流；
归还*这个；
}
迭代器运算符--（int）{
返回迭代器（当前--）；
}
迭代器和运算符+=（int n）{
电流+=n；
归还*这个；
}
迭代器和运算符-=（int n）{
电流-=n；
归还*这个；
}
布尔运算符！=（常量迭代器和rhs）常量{
返回电流！=rhs.current；
}
电气和操作员*（）{
返回*当前值；
}
//等等，对于RandomAccess迭代器需要实现的其他运算符。。。
};
迭代器begin（）{
返回迭代器（A）；
}
迭代器结束（）{
返回迭代器（A+3）；
}
};
int main（）{
阵列矢量1；
typedef ArrayVector:：迭代器迭代器array；
整数和=0；
for（迭代器数组p=vector1.begin（）；p！=vector1.end（）；++p）
总和+=*p；
std:：cout这是您程序的一个版本，经过了足够的修改，可以正常运行。我将迭代器移出并将其作为模板，因为它实际上不依赖于
ArrayVector
。迭代器是按值复制的。您可以看到一个工作版本

#包括
使用名称空间std；
模板
类迭代器数组{
元素*电流；
公众：
迭代器数组（元素*initLoc）{
电流=初始位置；
}
迭代器数组运算符+（int n）{
当前=&当前[n]；
归还*这个；
}
布尔运算符！=（迭代器数组常量&obj2）{
返回此->当前！=obj2.current；
}
迭代器数组运算符++（）{
电流=电流+1；
归还*这个；
}
电气和操作员*（）{
返回*当前值；
}
};
模板
类ArrayVector{
公众：
ArrayVector（）{
A=新元素[3]；
A[0]=1；
A[1]=2；
A[2]=3；
ptr=&A[0]；
}
常量迭代器数组开始（）{
返回迭代数组（ptr）；
}
常量迭代器数组结束（{
返回迭代数组（ptr+3）；
}
元素*A；
元素*ptr；
};
您的
ArrayVector
没有任何
begin
和
end
函数-您将这些函数定义为
iteratorArray
的成员，因为您是新来的，请阅读。对于像您这样的问题，需要进一步提取并提供一个。此外，您犯了一个错误，您咬了太多的东西。以较小的、渐进的步骤代替，例如，放弃整个“代码>模板……/代码>”。此外，为了跟踪您的进度，考虑“测试驱动开发”（为Web而开发Web！），这是许多编程任务的宝贵技术。为什么您有<代码>删除[]？A；

在您的

ArrayVector

复制构造函数中？对象是全新的，因此有什么可以

删除
？您的
开始
函数缺少
返回
函数，甚至没有声明返回迭代器，而是指向
ArrayVector
的指针。我需要在大学作业中使用迭代器
#include <iostream>
using namespace std;

template <class Elem>
class iteratorArray{
    Elem * current;
public:
    iteratorArray(Elem* initLoc){
        current = initLoc;
    }
    iteratorArray operator+(int n){
        current = &current[n];
        return *this;
    }
    bool operator!=(iteratorArray const& obj2){
        return this->current != obj2.current;
    }
    iteratorArray operator++(){
        current = current+1;
        return *this;
    }
    Elem& operator*(){
        return *current;
    }
};

template <class Elem>
class ArrayVector{
public :
    ArrayVector(){
        A = new Elem[3];
        A[0] = 1;
        A[1] = 2;
        A[2] = 3;
        ptr = &A[0];
    }

    const iteratorArray<Elem> begin(){
        return iteratorArray<Elem>(ptr);
    }
    const iteratorArray<Elem> end(){  
        return  iteratorArray<Elem>(ptr + 3);
    }

    Elem* A;
    Elem* ptr;
};