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

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; 

再次被调用=和B被引用为const传递（在这种情况下，它的问题。如果它是按值传递的？）这是我感到困惑的地方，属于a的x被赋值为be的param.x。那么为什么这个函数不是void，因为这个函数可以访问x和y。什么是return *这意味着，我知道这是调用函数的对象的地址，所以*这将是函数本身，但是如果我们要返回一个对象，我们需要将它分配到某处，如前面的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 &返回类型允许链接。

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

谢谢！

Answer 1

那么为什么这个函数没有void，因为x和y可以被这个函数访问。是什么返回*这意味着

由于operator=()声明为返回一个参考，return *this;返回当前对象的引用。这使我们能够连锁分配操作员。例如，

a = b = c; 

将调用b.operator=(c);并返回一个参考b。然后a由相当于a.operator=(b)的呼叫分配。

Answer 2

首先，C++中惯常的约定是将类类型 作为参数传递给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; 
} 

是合法的（即使很多，包括我自己，会认为这是坏 S型），所以相同的代码应该是合法的与类类型的 重载operator =。当然，编译器生成的 operator=将返回对const的引用，所以当您自己编写一个 时， 是一个很有力的参数。