c++中的赋值运算符重载

Question

我意识到在网络上重载赋值运算符的例子之后有例子，但我花了最后几个小时试图在我的程序中实现它们并弄清楚它们是如何工作的，但我似乎做不到它和任何帮助将不胜感激。

我正在尝试实现一个重载的赋值运算符函数。

我有 3 个文件在工作，Complex.h 头文件、Complex.cpp 定义文件和我用作测试我的 Complex 类的驱动程序的 .cpp 文件。

在 Complex.h 头文件中我的赋值运算符原型：

Complex &operator= (Complex&);

到目前为止，我在 .cpp 文件中对重载运算符的定义是：

    Complex &Complex::operator=(Complex& first)
    {
         if (real == first.real && imaginary == first.imaginary)
             return Complex(real, imaginary);

         return first;
    };

我在函数中调用赋值运算符的方式是：

   x = y - z;

所以具体来说，我的问题是，当我用 x = y -z 调用重载赋值运算符时，当我返回传入的值时它不会将传入的值分配给 x，我无法弄清楚为什么从网络上的众多示例和解释中，任何帮助都将不胜感激，我提前感谢您的任何帮助。

Answer 1

重载的赋值运算符应该如下所示：

Complex &Complex::operator=(const Complex& rhs)
{
     real = rhs.real; 
     imaginary = rhs.imaginary;
     return *this;
};

---

您还应该注意，如果您重载赋值运算符，您应该以相同的方式重载 Complex 的复制构造函数：

Complex::Complex(const Complex& rhs)
{
    real = rhs.real; 
    imaginary = rhs.imaginary;
};

Answer 2

我认为您需要以下运算符定义

Complex & Complex::operator =( const Complex &first )
{
     real = first.real;
     imaginary = first.imaginary;

     return *this;
};

您必须返回对分配给的对象的引用。此外，参数应该是一个常量引用。在这种情况下，您可以将引用绑定到临时对象，或者您还必须编写移动赋值运算符。

在复制赋值运算符的实现中，您不会更改分配的对象。:) 您只需创建一个临时对象并返回对该临时对象的引用或返回对第一个对象的引用。

Answer 3

Assignment 接受两个对象，一个是要赋值的对象，另一个是具有所需值的对象。

作业应该：

• 修改现有对象，该对象被分配给

作业不应：

• 创建一个新对象
• 修改具有所需值的对象。

假设我们正在处理的对象类型是：

struct S {
  int i;
  float f;
};

执行赋值的函数可能具有签名：

void assignment(S &left_hand_side, S const &right_hand_side);

它会被使用：

S a = {10, 32.0f};

S b;

assignment(b, a);

注意：

• 左侧对象是可修改的，赋值会修改它，而不是创建一个新对象。
• 右侧对象，即具有所需值的对象，不可修改。

此外，在 C++ 中，内置的赋值操作是表达式而不是语句；它有一个值，可以用作子表达式：

int j, k = 10;

printf("%d", (j = k));

这会将 j 设置为 k，然后获取该赋值的结果并将其打印出来。需要注意的重要一点是赋值表达式的结果是被赋值给的对象。没有创建新对象。在上面的代码中，j 的值被打印出来了（也就是 10，因为 j 刚刚从 k 分配了值 10）。

更新我们之前的分配函数以遵循此约定会产生如下签名：

S &assignment(S &left_hand_side, S const &right_hand_side);

实现如下：

S &assignment(S &left_hand_side, S const &right_hand_side) {
  // for each member of S, assign the value of that member in 
  // right_hand_side to that member in left_hand_side.
  left_hand_side.i = right_hand_side.i;
  left_hand_side.f = right_hand_side.f;

  // assignment returns the object that has been modified
  return left_hand_side;
}

注意这个赋值函数不是递归的；它不会在赋值中使用自己，但确实使用了成员类型的赋值。

难题的最后一部分是让语法a = b 起作用，而不是assignment(a, b)。为此，您只需将assignment () 设为成员函数：

struct S {
  int i;
  float f;

  S &assignment(S &left_hand_side, S const &right_hand_side) {
    left_hand_side.i = right_hand_side.i;
    left_hand_side.f = right_hand_side.f;
    return left_hand_side
  }
};

将left_hand_side 参数替换为*this：

struct S {
  int i;
  float f;

  S &assignment(S const &right_hand_side) {
    this->i = right_hand_side.i;
    this->f = right_hand_side.f;
    return *this;
  }
};

并将函数重命名为operator=:

struct S {
  int i;
  float f;

  S &operator=(S const &right_hand_side) {
    this->i = right_hand_side.i;
    this->f = right_hand_side.f;
    return *this;
  }
};

int main() {
  S a, b = {10, 32.f};

  S &tmp = (a = b);

  assert(a.i == 10);
  assert(a.f == 32.f);

  assert(&tmp == &a);
}

另一件重要的事情是= 符号用在一个不是赋值的地方：

S a;
S b = a; // this is not assignment.

这是“复制初始化”。它不使用operator=。这不是任务。尽量不要混淆两者。

要记住的要点：

• assignment 修改了被分配的对象
• 赋值不会修改被赋值的对象。
• 赋值不会创建新对象。
• 赋值不是递归的，除非复合对象的赋值利用了它包含的所有小成员对象的赋值。
• assignment 修改值后返回对象
• 复制初始化看起来有点像赋值，但与赋值关系不大。