C++ 当相应的对象作为常量传递时，如何将向量作为类的成员进行迭代_C++

C++ 当相应的对象作为常量传递时，如何将向量作为类的成员进行迭代

c++

C++ 当相应的对象作为常量传递时，如何将向量作为类的成员进行迭代,c++,C++,我有一个只有一个成员的简单类，它是一个向量，如下所示： class MyClass{ private: vector<double> vector_member; public: method_1(); method_2(); .... }; class-MyClass{ 私人：向量_成员；公众：方法1（）；方法2（）； .... }; 当我试图重载一个操作符，比如+=，它应该在两个对象的向量中添加每个元素，并返回一个向量作为它们的总和。

我有一个只有一个成员的简单类，它是一个向量，如下所示：

class MyClass{
private:
    vector<double> vector_member;
public:
    method_1();
    method_2();
    ....
};

class-MyClass{
私人：
向量_成员；
公众：
方法1（）；
方法2（）；
....
};

当我试图重载一个操作符，比如+=，它应该在两个对象的向量中添加每个元素，并返回一个向量作为它们的总和。到目前为止，我的做法是：

MyClass& MyClass :: operator+=(const MyClass& p){
    size_t n = max(this->vector_member.size(),p.vector_member.size());
    MyClass temp;
    for (size_t i = 0; i < n; ++i){
        temp.vector_member.push_back(0);
    }
    vector<double>::iterator it_1 = this->vector_member.begin();
    vector<const double>::iterator it_2 = p.vector_member.begin();
    vector<double>::iterator it_3 = temp.vector_member.begin();

    for (; it_1 != this->vector_member.end(); ++it_1, ++it_3){
        *it_3 += *it_1;
    }

    it_3 = temp.vector_member.begin();

    for (; it_2 != p.vector_member.end(); ++it_2, ++it_3){
        *it_3 += *it_2;
    }

    return temp;
}

MyClass&MyClass:：operator+=（常量MyClass&p）{
size\u t n=max（this->vector\u member.size（），p.vector\u member.size（））；
我的班级温度；
对于（尺寸i=0；ivector_成员.begin（）；
向量：：迭代器it_2=p.vector_成员.begin（）；
vector:：iterator it_3=临时向量_成员.begin（）；
对于（；it_1！=this->vector_member.end（）；++it_1，++it_3）{
*it_3+=*it_1；
}
it_3=临时向量_成员.begin（）；
for（；it_2！=p.vector_member.end（）；++it_2，++it_3）{
*it_3+=*it_2；
}
返回温度；
}

我设置临时向量的原因是，我需要一个具有这两个向量的最大大小的向量，以避免分段错误

我的问题是每次尝试执行

vector:：iterator it_2=p.vector_member.begin（）或it_2！=p、 vector_member.end（）

vs代码似乎对此不满意。它表示不能在“\uu gnu\u cxx:：\uu normal\u迭代器”
和“\uu gnu\u cxx:：\uu normal\u迭代器”

我不知道如何解决这个问题，还有什么聪明的方法吗？我觉得我的密码太坏了。谢谢
vector<const double>::iterator it_2 = p.vector_member.begin();

让芯片落在它们可能落下的地方
另外，由于与编译错误无关的原因，您实现的运算符从根本上被破坏了：它返回对临时对象的引用。如果返回的不是引用而是temp
值本身，而不是对它的引用，那么您实际上实现了一个操作符+
。操作符+=
应该修改自身，而不是创建新对象并返回它。在任何情况下，似乎有一种更简单、更短的方法来实现逻辑等效的操作符+
：从*复制构建临时
，将其向量调整为相同的max（）
值（将自动为零初始化任何新值），然后简单地将另一个向量的值添加到副本的向量中。大约是代码的一半。
输入的MyClass p
对象是const
，因此它的向量也是const
，因此您需要使用向量：：const\u迭代器来迭代它的元素，而不是向量：：迭代器
。这就是为什么会出现编译器错误
但是，即使解决了这个问题，您的代码仍然是错误的操作符+=
应该修改此
，然后返回*此
。但你没有这样做。您正在创建一个全新的MyClass
对象，并返回对该对象的（悬空）引用。您的operator+=
的行为更像operator+
应该采取的行动（请参阅）
请尝试以下方法：
MyClass&MyClass:：operator+=（常量MyClass&p）{
size_t n=p.vector_member.size（）；
如果（n>this->vector_member.size（））
此->向量_成员。调整大小（n）；
vector:：iterator it_1=this->vector_成员.begin（）；
vector:：const_迭代器it_2=p.vector_成员.begin（）；
对于（尺寸i=0；ivector\u member.size（），p.vector\u member.size（））；
标准：向量温度（n，0.0）；
vector:：iterator it_1=this->vector_成员.begin（）；
vector:：const_迭代器it_2=p.vector_成员.begin（）；
向量：：迭代器it_3=it_3=temp.begin（）；
while（it_1！=this->vector_member.end（））{
*it_3++=*it_1++；
}
it_3=温度开始（）；
while（it_2！=p.vector_member.end（））{
*it_3++=*it_2++；
}
此->向量_成员=std:：move（temp）；
*/
归还*这个；
}
MyClass运算符+（常量MyClass和lhs、常量MyClass和rhs）{
MyClass温度（lhs）；
温度+=rhs；
返回温度；
}
这是否回答了您的问题？对于const值，需要一个const迭代器。
vector<double>::const_iterator it_2 = p.vector_member.begin();

auto it_2 = p.vector_member.begin();