什么'；重载运算符有错吗？ 我学习C++（如果操作精确，则重载运算符）。我通过以下方式尝试重载运算符+： Complex4d Complex4d::operator+(const Complex4d &rvalue) { return Complex4d(a() + rvalue.a(), b()); } Complex2d Complex2d::operator +(Complex2d &rvalue) { return Complex2d(a() + rvalue.a(), b() + rvalue.b()); }

其中rvalue.a（）和a（），rvalue.b（）和b（）是Complex2d的对象。在Complex2d I类中，通过以下方式重载运算符+：

Complex4d Complex4d::operator+(const Complex4d &rvalue)
{
    return Complex4d(a() + rvalue.a(), b());
}

Complex2d Complex2d::operator +(Complex2d &rvalue)
{
    return Complex2d(a() + rvalue.a(), b() + rvalue.b());
} 

如果我这样写：

Complex4d Complex4d::operator+(const Complex4d &rvalue)
{
    Complex2d test = rvalue.a();
    return Complex4d(a() + test, b());
}

---

没关系。我做错了什么？

问题是您试图将临时引用绑定到非常量引用，这是不允许的，也没有意义：

Complex2d Complex2d::operator +(Complex2d &rvalue)
                                ^^^^^^^^^^^
return Complex4d(a() + rvalue.a(), b());
                       ^^^^^^^^^^

要修复它，请使用常量引用，临时变量可以绑定到该引用。常量正确性也适用。如果您没有修改它（您不应该修改），请将其设置为

const

Complex2d Complex2d::operator +(const Complex2d &rvalue)
                                ^^^^^

另一个参数（

*此

）也未修改：

Complex2d Complex2d::operator +(const Complex2d &rvalue) const
                                ^^^^^                    ^^^^^                

此外，我建议让它们成为自由函数并重用其他代码：

Complex2d operator+(const Complex2d &lhs, const Complex2d &rhs) {
    auto ret = lhs;
    ret += rhs;
    return ret; //see comments for implementation reasoning
}

---

这使得左侧的行为与右侧相同，并通过减少一个不必要的函数来访问类的私有成员来改进封装。

问题是您试图将临时绑定到非常量引用，这是不允许的，也没有意义：

Complex2d Complex2d::operator +(Complex2d &rvalue)
                                ^^^^^^^^^^^
return Complex4d(a() + rvalue.a(), b());
                       ^^^^^^^^^^

要修复它，请使用常量引用，临时变量可以绑定到该引用。常量正确性也适用。如果您没有修改它（您不应该修改），请将其设置为

const

Complex2d Complex2d::operator +(const Complex2d &rvalue)
                                ^^^^^

另一个参数（

*此

）也未修改：

Complex2d Complex2d::operator +(const Complex2d &rvalue) const
                                ^^^^^                    ^^^^^                

此外，我建议让它们成为自由函数并重用其他代码：

Complex2d operator+(const Complex2d &lhs, const Complex2d &rhs) {
    auto ret = lhs;
    ret += rhs;
    return ret; //see comments for implementation reasoning
}

---

这使得左侧的行为与右侧相同，并通过减少一个访问类的私有成员的不必要函数来改进封装。

operator+

通常应该是一个自由函数，只返回lhs+=rhs。你的意思是，我需要将运算符+实现为类函数外的，而不是类的成员吗？你不必，但如果你想运算符与LHS和RHS完全对称，你应该这样做。@chris：不是根据什么引用？霍华德·辛纳特？除了他说的是“RVO”而不是“NRVO”，我完全同意他的说法<代码>移动防止NRVO。提出一个问题可能是个好主意。真正的技巧应该是

lhs+=rhs；返回lhs，它不会阻止NRVO并隐式移动。（
lhs+=rhs
返回对
lhs
的左值引用，该左值引用既不能是NRVO'd也不能是
隐式移动
d）。尽管如此，
std:：move（lhs+=rhs）
或
std:：move（lhs）==rhs
似乎更为动人。
operator+
通常应该是一个自由函数，只返回
lhs+=rhs
。你的意思是，我需要将运算符+实现为类函数外的，而不是类的成员吗？你不必，但如果你想运算符与LHS和RHS完全对称，你应该这样做。@chris：不是根据什么引用？霍华德·辛纳特？除了他说的是“RVO”而不是“NRVO”，我完全同意他的说法<代码>移动

防止NRVO。提出一个问题可能是个好主意。真正的技巧应该是

lhs+=rhs；返回lhs，它不会阻止NRVO并隐式移动。（
lhs+=rhs
返回对
lhs
的左值引用，该左值引用既不能是NRVO'd也不能是
隐式移动
d）。尽管如此，
std:：move（lhs+=rhs）
或
std:：move（lhs）==rhs
似乎更令人感动。在
const
引用上调用
+=
不会很好地工作：-）我会传递值，然后只返回lhs+=rhs

@juanchopanza，哎呀，我做了吗？一秒钟，更好！如果没有RVO，

移动

也是如此吗？@juanchopanza，请参阅关于这个问题的评论。要么我记得正确，现在不可能有RVO，要么，更可能的是，我的记忆很差，现在有可能出现这两种情况。似乎反对在这种情况下搬家。我怀疑Hinnant也知道他的东西：）在

常量

引用上调用

+=

不会很好：-）我会通过值传递，然后只

返回lhs+=rhs

@juanchopanza，哎呀，是我做的吗？一秒钟，更好！如果没有RVO，

移动

也是如此吗？@juanchopanza，请参阅关于这个问题的评论。要么我记得正确，现在不可能有RVO，要么，更可能的是，我的记忆很差，现在有可能出现这两种情况。似乎反对在这种情况下搬家。我怀疑Hinnant也知道他的事：）