4

CVector 类中的运算符重载：

CVector CVector::operator+ (CVector param) {
  CVector temp;
  temp.x = x + param.x;
  temp.y = y + param.y;
  return (temp);
}

主要是：

CVector a (3,1);
  CVector b (1,2);
  CVector c;
  c = a + b;

所以一个对象是按值传递的，然后另一个临时对象正在被创建。我猜b是按值传递的，a是调用+的那个，因此x和y属于a，pram.x和param.y属于b。temp 被返回，复制赋值运算符将 temp 的值传递给 c?

但是这个呢：

CVector& CVector::operator= (const CVector& param)
{
  x=param.x;
  y=param.y;
  return *this;
}

主要是：

a=b;

再次 a 调用 = 并且 b 通过引用作为 const 传递。（在这种情况下，它是否按值传递是否重要？）这是我感到困惑的地方，属于 a 的 x 被分配了 be 的 param.x。那么为什么这个函数不是 void，因为 x 和 y 可以被这个函数访问。return *this 是什么意思，我知道这是调用函数的对象的地址，所以 *this 将是函数本身，但是如果我们要返回一个对象，我们需要将它分配给前面的 c=temp在 temp=a+b 之后？CVector& 甚至意味着什么，它看起来不像我们期望一个 CVector 类型的对象的地址？

换句话说，为什么这个功能不只是：

void CVector::operator= (const CVector& param)
    {
      x=param.x;
      y=param.y;
    }

??

然后就是这段代码

#include <iostream> 
using namespace std;
 class Calc { 
private: 
  int value; 
public: 
  Calc(int value = 0) { this->value = value; } 
  Calc& Add(int x) { value += x; return *this; } 
  Calc& Sub(int x) { value -= x; return *this; } 
  Calc& Mult(int x) { value *= x; return *this; } 
  int GetValue() { return value; } }; 

int main() { 
  Calc cCalc(2); 
  cCalc.Add(5).Sub(3).Mult(4); 
  cout << cCalc.GetValue(); 
  return 0; 
}

现在，如果我从函数中删除 & ：

  Calc Add(int x) { value += x; return *this; } 
  Calc Sub(int x) { value -= x; return *this; } 
  Calc Mult(int x) { value *= x; return *this; }

并使用

Calc cCalc(2)
cCalc.Add(5);
cCalc.Sub(3);
cCalc.Mult(4);

而不是前者，它将产生相同的结果。那么为什么 Calc& 返回类型允许链接。

我不仅想知道如何编程，因为面向对象是通过模式编写的（这是这样写的，如果那样的话，这是需要的）与必须使用逻辑的结构化编程相反，而且还要知道为什么是按原样定义的代码和平，以及为什么它不像我直觉认为的那样（尽管我只学习了大约一年的编程）。

谢谢！

4

2 回答 2

2

那么为什么这个函数不是 void，因为 x 和 y 可以被这个函数访问。return *this 是什么意思

由于operator=()被声明为返回一个引用，return *this;所以返回一个对当前对象的引用。这允许我们链接赋值运算符。例如，

a = b = c;

将调用b.operator=(c);并返回对b. 然后a由等效于 的调用分配a.operator=(b)。

于 2013-08-23T15:25:27.933 回答
1

首先，C++ 中通常的约定是将类类型参数作为对 const 的引用传递。显然有例外（标准库中的谓词对象或迭代器），但在应用程序级代码中，通过引用 const 传递类类型无处不在，足以证明注释的合理性：

Vector
Vector::operator+( Vector const& rhs ) const
{
    //  ...
}

或者更有可能：

Vector
operator+( Vector const& lhs, Vector const& rhs )
{
    Vector results( lhs );
    results += rhs;
    return results;
}

另一个普遍的约定是使此类二元运算符成为自由函数，以便以相同的方式处理左右参数。并以 = 的形式实现它们，以确保 = 和具有所需的关系。

对于修改左参数的运算符，例如赋值运算符，另一方面，使它们成为成员是惯例；operator=实际上必须是成员。自由函数Vector& operator+=( Vector& lhs, Vector const& rhs )是合法的，但相当不寻常。

至于为什么operator=返回Vector&：约定。它最准确地模拟了内置运算符的作用：

int&
MyClass::funcWithInt( int newValue )
{
    return myInt = newValue;
}

是合法的（即使包括我自己在内的许多人都认为它是错误的 stype），因此对于重载 operator= 的类类型，相同的代码应该是合法的。当然，生成的编译器 operator=会返回一个对 const 的引用，所以当你自己写一个时，有一个强有力的论据来做同样的事情。

于 2013-08-23T15:20:20.617 回答