Верните это или * это при перегрузке оператора?

Question

Я пытаюсь перегрузить операторов на C++. Для этой цели, я написал следующий код:

#include <iostream> 

using namespace std; 

class Box 
{ 
public: 
    int height; 
    int width; 
    int length; 
public: 
    Box operator+(const Box& b) 
    { 
     this->length = this->length + b.length; 
     this->width = this->width + b.width; 
     this->height = this->height + b.height; 

     return *this; 
    } 


}; 




int main() 
{ 
    Box b1,b2; 

    b1.length = 5; 
    b1.width = 5; 
    b1.height = 5; 

    cout << "Length is : " << b1.length; 
    cout << "width is : " << b1.width; 
    cout << "height is : " << b1.height; 

    b2.length = 5; 
    b2.width = 5; 
    b2.height = 5; 

    b1 = b1 + b2 ; 

    cout << "Length is : " << b1.length; 
    cout << "width is : " << b1.width; 
    cout << "height is : " << b1.height; 


    cout << "Hello from first c++"; 
    return 0; 
} 

Основная часть:

Box operator+(const Box& b) 
     { 
      this->length = this->length + b.length; 
      this->width = this->width + b.width; 
      this->height = this->height + b.height; 

      return *this; 
     } 

Я не могу понять:

1. this-> длина = это -> длина + b.length;

2. возвращение * этот;

this.length не работает здесь. Почему я должен return *this? Нужно ли return this?

Answer 1

1) «это» является указателем 2) «это» указатель является постоянным указателем, который содержит адрес памяти текущего объекта

подпись пользователя: оператора бокса + (Const коробка & б)

«Почему я должен возвращать это? Это возвращение здесь недостаточно?»

Если вы вернете «это», вы должны будете вернуть указатель Box *, и ваша подпись участника не согласуется с этим.

Следовательно, вам нужно вернуться по значению и, следовательно, разыскать его и вернуться.

Answer 2

Вы хотите вернуть *this всякий раз, когда вы возвращаете ссылку или копию, и this, только если вы вернете указатель на объект класса (которого вы почти никогда не будете).

Answer 3

"этот" является указателем на объект типа Box. Ваш тип возврата - это конкретный объект типа Box.

Когда вы вернетесь * это, вы разыменования указателя и возвращает ссылку на ваш объект (Box &), который затем ваш компилятор преобразует в новый объект, используя конструктор копирования Box (Const Box &).

На самом деле, если вы написали b3 = b1 + b2, вы заметите, что модификация b3 не изменит b1 дальше. Это касательно письма вашего вопроса.

В качестве побочного примечания, однако, вы немного путаетесь в том, как вы определяете своего оператора. Обычно, когда вы перегружаете свой арифметический оператор, вы можете перегрузить как оператор +, так и оператор + =

оператор + возвращает новый конкретный объект данного типа и не должен изменять операнд. Это типично подпись:

Box Box::operator+(const Box& R) const 

Таким образом, типичный способ осуществить это, чтобы сделать копию одного из двух операндов, а затем сделать сумму и вернуть этот новый объект.Обратите внимание, что функция объявлена ​​постоянной

Если вы хотите изменить первый операнд так, как вам кажется, вы хотите использовать оператор + =. Этот оператор имеет другую подпись и предполагает, что вы модифицируете операнд, и в этом случае он фактически возвращает ссылку, которая должна быть ссылкой на левый операнд. Так что в этом случае вы будете иметь

Box& Box::operator+=(const Box& R) 

И в этом случае вы можете видеть, что функция не является постоянной, потому что вы, что вы хотите изменить свой операнд, и в этом случае вы должны вернуть * это, которое является ссылкой на объект, который вы только что изменили.

Quick guide on operator overloading

Answer 4

(Откладывая факт, что ваш operator+() изменяет значение this) причину вы возвращаетесь *this, чтобы позволить такие выражения, как, что:

Box a, b, c; 
// ... init the Boxes 
Box d = a + b + c; 

В этом случае результат a+b потребностей «быть» в operator+, чтобы добавить в него значение c. Это делается путем создания нового временного объекта, который представляет результат a+b (в вашем случае - это то, что возвращается как *this в вашем operator+).

Теперь вы должны увидеть, что если вы должны были вернуть указатель this, то не было бы никакого способа, чтобы элегантно записать a+b+c как результат a+b больше не будет являться ссылкой и для того, чтобы правильно называть operator+ на это можно было бы написать что-то уродливое, как:

(a+b).operator+(c) 

то же рассуждение идет на уступки operator= в приведенном выше выражении - вы действительно хотите, чтобы вернуть ссылку на ваш объект, а не указатель на него.