Question

类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被赋值为param.x是的。那么为什么这个函数不是空的，因为这个函数可以访问x和y。返回*这意味着什么，我知道这是调用函数的对象的地址，所以*这将是函数本身，但是如果我们返回一个对象，我们需要将它分配给某个地方，就像之前的c = temp一样在temp = a + b之后？什么是CVector＆amp;甚至意味着，看起来我们不期待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; 
}

现在，如果我删除＆amp;来自功能：

  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＆amp;返回类型允许链接。

我不仅想知道如何编程，因为面向对象是一种模式编写（这是这样编写的，如果需要的话），这与结构化编程相反，你必须使用逻辑，但也要知道为什么代码的和平定义为它，为什么它不是我直觉认为它应该是（虽然我只学习编程大约一年）。

谢谢！

Answer 1

所以为什么这个函数不是空的，因为这个函数可以访问x和y。返回*这意味着什么

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

a = b = c;

将致电b.operator=(c);并返回对b的引用。然后通过相当于a的调用分配a.operator=(b)。

Answer 2

首先，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;
}

另一种广泛的惯例是制作这样的二元运算符自由函数，左右参数都是ar 以同样的方式对待。并根据实施它们 =，以确保=并具有所需的关系。

对于修改左参数的运算符，如赋值运算符，另一方面是约定让他们成员; operator=实际上必须是会员。免费功能Vector& operator+=( Vector& lhs, Vector const& rhs )是合法的，但却很不寻常。

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

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

是合法的（即使很多人，包括我自己，也会认为这很糟糕） stype），所以相同的代码应该是合法的类类型重载operator =。当然，编译器生成了 operator=将返回对const的引用，所以有当你写一篇论文时，这是一个强有力的论据自己。

通过类函数返回引用并在c ++中返回整个对象？

2 个答案: