C++ 的哪个变体？我应该使用运算符重载吗？而且，为什么？

Question

这里给出了加法运算符 (+) 重载的 3 种变体。

我应该使用哪种变体以及为什么？

class MyClass {
    int myInteger;
    double myDouble;
    public:
        MyClass(int i, double d) {
        myInteger = i;
        myDouble = d;
    }

    // Variation - 1
    //--------------
    MyClass operator +(MyClass rhsObj) {
        return MyClass(this->myInteger + rhsObj.myInteger, this->myDouble + rhsObj.myDouble);
    }

    // Variation - 2
    //--------------
    MyClass &operator +(MyClass &rhsObj) {
        rhsObj.myInteger = this->myInteger + rhsObj.myInteger;
        rhsObj.myDouble = this->myDouble + rhsObj.myDouble;

        return rhsObj;
    }

    // Variation - 3
    //--------------    
    MyClass &operator +(MyClass &rhsObj) {
        this->myInteger = this->myInteger + rhsObj.myInteger;
        this->myDouble = this->myDouble + rhsObj.myDouble;

        return *this;
    }
};


int main() {
    MyClass objOne(10, 10.5);
    MyClass objTwo(20, 20.5);

    MyClass objThree = objOne + objTwo;
}

赋值运算符（=）应该是什么情况？应该使用哪种变体？

Answer 1

取决于你需要什么。

首先，关于您的版本 - 显然

• “变体 - 1”创建新对象，而不触及两个操作数。
• “Variation - 2”将结果存储在第二个操作数中
• ，“Variation - 3”将结果存储在“this”中的第一个操作数中。

---

最有可能的是，Variation - 1 是最优选的。

为什么？因为有副作用。如果您看到这样的表达式：

a = b + c;

无论 a、b 和 c 的类型是什么，您会怎么想？我认为，a是b和c以及b和c的总和code> 未受影响，我的意思是 - 使用旧值。
例如，假设：

a = 5;
b = 6;
c = a + b;

您是否期望 a 或 b 在求和后会变成 11？ （如果您选择变体 2 或 3，就会发生这种情况）。当然，您不能为int重载operator+，但这只是一个简单直观的示例。

---

一项性能改进：在您的变体 1 中，而不是

MyClass operator+(MyClass rhsObj)

我会使用

MyClass operator+(const MyClass& rhsObj)

这种方式，您将避免一份额外的副本+您将使用您的代码告诉“客户端”您不会更改 rhsObj根本没有，但只是利用它的价值。

Answer 2

您确实想要这里的一个和三个的变体。

MyClass 的用户希望它遵循最小惊讶原则并且绝不会期望看到右侧因加法而被修改。使用 const more 将强制执行此操作，并且也将用作文档。如果您想修改左侧，请使用+=。像这样：

// Plus: Modify neither the left nor the right
//--------------
MyClass operator +(const MyClass& rhsObj) const
{
    return MyClass(myInteger + rhsObj.myInteger, myDouble + rhsObj.myDouble);
}

// Increment: Modify the left
//--------------
MyClass& operator +=(const MyClass& rhsObj)
{
    myInteger += rhsObj.myInteger;
    myDouble += rhsObj.myDouble;

    return *this;
}

演示：http://ideone.com/8oarA

Answer 3

这三个 + 之间存在细微差别。

第一个变化：

// Variation - 1
//--------------
MyClass operator+(MyClass rhsObj)
{
    return MyClass(this->myInteger + rhsObj.myInteger, this->myDouble + rhsObj.myDouble);
}

将 MyClass 的对象作为输入，这意味着 rhsObj 的副本是传递到 + 中，原始对象 rhsObj 保持不变。此覆盖返回一个新创建的 MyClass 对象。

第二种变体：

// Variation - 2
//--------------
MyClass & operator+(MyClass & rhsObj)
{
    rhsObj.myInteger = this->myInteger + rhsObj.myInteger;
    rhsObj.myDouble = this->myDouble + rhsObj.myDouble;

    return rhsObj;
}

将 rhsObj 的引用作为输入，并在方法中更新 rhsObj。

最后一个变体

// Variation - 3
//--------------    
MyClass & operator+(MyClass & rhsObj)
{
    this->myInteger = this->myInteger + rhsObj.myInteger;
    this->myDouble = this->myDouble + rhsObj.myDouble;

    return *this;
}

也采用对 rhsObj 的引用作为参数，但 rhsObj 未在方法内部进行修改。相反，调用 + 的 MyClass 对象会更新。

Answer 4

从概念上讲，您想要返回一对新的，因此在您的情况下，第一个变体可能更好。

或者也许您想返回参数之一，但后来我发现运算符的名称令人困惑。对于第三个变体，+= 可能会更好。

Answer 5

我认为变体 1 最好，主要有一个原因：如果您只有语句 lhs + rhs;，您会期望/想要 lhs 或 rhs< /code> 要修改吗？我知道在大多数（所有？）情况下我可能不会。

因此排除了变体 2 和 3。