c++ - 具有返回值的函数 (C++)

Question

当 main() 调用具有某种数据类型(原始或用户定义)返回值的函数时，调用该函数的语句“通常”是一个赋值。

例如:-

class complex
{

private:

    int real;
    int imag;

public:

    complex();
    complex(int r,int i);
    complex operator + (complex c);
};

假设，我重载的“+”的定义是这样的-

complex complex::operator + (complex c)
{
    this->real = this->real + c.real;
    this->imag = this->imag + c.imag;
    return *this;
}

我的主要功能如下-

int main()
{
    complex c1;
    complex c2(5,4);
    c1+c2;
}

在上面的 main() 中，考虑语句 c1+c2 。编译器将其视为 c1.operator + (c2) 。当 main 调用此函数时，它会向 main() 返回一个值。这个返回值会发生什么？？

Answer 1

表达式 c1+c2 的值被您的代码忽略，因为您没有将它存储在任何地方。最多，编译器会打印一些警告信息。要禁止此类警告消息，您可以编写:

(void)(c1+c2); //casting to void suppresses the warning messages!

看这个:

• Why cast unused return values to void?

---

您的代码的真正问题..

但是，在您的代码中，operator+ 的实现在语义上不正确。要了解这一点，请考虑这一点，

 int a=10;
 int b=5;

那么，你希望a+b改变a的值吗？ a 应该变成 15 吗？没有。

如果你想要那个，那么你可以写成a+=b。但在您的代码中，c1+c2 的行为等同于 c1+=c2 的语义，因为您正在更新 this->real 的值> 和 this->imag 在您的 operator+ 实现中，这在语义上是不正确的。

所以第一个修复是这样的:

complex complex::operator + (const complex& c) const
{                            
  complex result(c); //make a copy of c
  result.real += this->real; //add
  result.imag += this->imag; //add
  return result;
}

现在，这在语义上是正确的。

也就是说，还有一些事情需要注意。当您编写c1+c2 时，您是否认为操作+ 应用于其中一个对象？不，它不适用于它们中的任何一个，但是成员函数 operator+ 在 c1 对象上被调用，该对象成为函数内部的 this 指针.如果操作不适用于它，为什么要在 c1(或者就此而言 c2)上调用它？

这个分析清楚地表明 operator+ 不应该是类的成员函数。它应该是一个非成员函数，然后签名将是:

complex operator+(const complex &a, const complex &b);

但是有个小问题:在a+b的计算中，需要访问类的私有(private)成员(real和imag 是私有(private)成员)。所以解决方案是，operator+应该根据operator+=来实现，后者应该作为成员函数添加到类中， 因为表达式 a+=b 中的操作 += 确实适用于 a，因为它修改了它的值。

所以这是我对这两个运算符的实现:

class complex
{
  //...
  public:

    //member function
    complex& operator+=(const complex & c)
    {
          real += c.real; //same as: this->real+=c.real; this is implicit
          imag += c.imag; //same as: this->imag+=c.real; this is implicit
          return *this;
    }
};

//non-member function (its non-friend as well)
complex operator+(const complex &a, const complex &b)
{
    complex result(a); //make copy of a by invoking the copy-constructor
    result += b;  //invokes operator+
    return result;
}

或者您可以加入最后两个语句:

complex operator+(const complex &a, const complex &b)
{
    complex result(a); //make copy of a by invoking the copy-constructor
    return result += b;  //invokes operator+, and then return updated 'result'
}

但是还有另一种复制方式。为什么要通过引用传递这两个参数？按值传递第一个参数将生成我们需要的拷贝。所以更好的实现是这样的:

complex operator+(complex a, const complex &b)
{               //^^^^^^^^^ pass-by-value
    a += b; //a is a copy, after all - we can modify it!
    return a;
}

希望对您有所帮助。