Operatori che sovraccaricano in C++

Question

Recentemente ho scoperto di sovraccaricare gli operatori in C++. Quando si vuole sovraccaricare un operatore in classe e vogliamo creare nuovo oggetto con esso, che è fatto da altri, abbiamo definito che possiamo fare

NameOfClass operator+(const NameOfClass& b){ 
    { 
     NameOfClass tmp; 
     tmp.length = this->length + b.length; 
     tmp.breadth = this->breadth + b.breadth; 
     tmp.height = this->height + b.height; 
     return tmp; 

} 

Non riesco a capire se mi definisco 2 oggetti prima di questo. Ad esempio

NameOfClass one(length,breadth,height); 
NameOfClass two(length,breadth,height); 

Ho impostato i loro attributi. ma come si fa

NameOfClass three=one+two; 

impostare gli attributi di "tre"? Sono entrambi uno e due considerati come argomento per "+" operatore sovraccarico. La funzione dice chiaramente

tmp.length = this->length + b.length; 

ma questa-> lunghezza deve essere indefinita e b.lunghezza è privata. Come si mescola? O è preso come metodo in modo one+two = il + è il metodo di uno e due viene passato come argomento, il che significa che questa lunghezza-> reffers to to length of "one" object? Utilizzo di esempio da tutorialspoint.

#include <iostream> 
using namespace std; 

class Box 
{ 
    public: 

     double getVolume(void) 
     { 
     return length * breadth * height; 
     } 
     void setLength(double len) 
     { 
      length = len; 
     } 

     void setBreadth(double bre) 
     { 
      breadth = bre; 
     } 

     void setHeight(double hei) 
     { 
      height = hei; 
     } 
     // Overload + operator to add two Box objects. 
     Box operator+(const Box& b) 
     { 
     Box box; 
     box.length = this->length + b.length; 
     box.breadth = this->breadth + b.breadth; 
     box.height = this->height + b.height; 
     return box; 
     } 
    private: 
     double length;  // Length of a box 
     double breadth;  // Breadth of a box 
     double height;  // Height of a box 
}; 
// Main function for the program 
int main() 
{ 
    Box Box1;    // Declare Box1 of type Box 
    Box Box2;    // Declare Box2 of type Box 
    Box Box3;    // Declare Box3 of type Box 
    double volume = 0.0;  // Store the volume of a box here 

    // box 1 specification 
    Box1.setLength(6.0); 
    Box1.setBreadth(7.0); 
    Box1.setHeight(5.0); 

    // box 2 specification 
    Box2.setLength(12.0); 
    Box2.setBreadth(13.0); 
    Box2.setHeight(10.0); 

    // volume of box 1 
    volume = Box1.getVolume(); 
    cout << "Volume of Box1 : " << volume <<endl; 

    // volume of box 2 
    volume = Box2.getVolume(); 
    cout << "Volume of Box2 : " << volume <<endl; 

    // Add two object as follows: 
    Box3 = Box1 + Box2; 

    // volume of box 3 
    volume = Box3.getVolume(); 
    cout << "Volume of Box3 : " << volume <<endl; 

    return 0; 
} 

Answer 1

1.

come si fa

NameOfClass three=one+two; 

impostare gli attributi di "tre"?

NameOfClass three=one+two; sarà interpretato come NameOfClass three = one.operator+(two);, e three sarà copiare/spostare costruito dal valore di ritorno di NameOfClass::operator=().

2.

tmp.length = this->length + b.length; 

ma this-> lunghezza dovrebbe essere indefinito e b.length è privato. Come si mescola insieme?

Cosa intendete "questa-> lunghezza deve essere indefinita"? Qui this == &one e b == two.

b.length è private non importa, perché operator+ è la funzione di membro, si potrebbe accesso al membro privato.

Answer 2

NameOfClass three = one + two; userà un costruttore copia generato dal compilatore per costruire three dal anonimo temporaneaone + two. one + two è zucchero sintattico per one.operator+(two) che è stato implementato.

compilatori più intelligenti possono anche utilizzare un generato dal compilatore mossa costruttore dal momento che è chiaro che il anonimo temporanea non può essere utilizzato da qualsiasi altra cosa.

È possibile implementare tali costruttori autonomamente o affidarsi al compilatore che ne genera uno che copia (o sposta i dati del membro).