Zuweisungsoperator in c Überlastung ++

Question

ich den folgenden Code für Zuweisungsoperator Überlastung verwendet haben:

SimpleCircle SimpleCircle::operator=(const SimpleCircle & rhs) 
{ 
    if(this == &rhs) 
     return *this; 
    itsRadius = rhs.getRadius(); 
    return *this; 
} 

My Copy Constructor ist dies:

SimpleCircle::SimpleCircle(const SimpleCircle & rhs) 
{ 
    itsRadius = rhs.getRadius(); 
} 

In dem obigen Betreiber Überlastung Code, Copy-Konstruktor aufgerufen wird da wird ein neues Objekt erschaffen; daher habe ich den folgenden Code:

SimpleCircle & SimpleCircle::operator=(const SimpleCircle & rhs) 
{ 
    if(this == &rhs) 
     return *this; 
    itsRadius = rhs.getRadius(); 
    return *this; 
} 

Seine gut funktionierend und das Kopierkonstruktor Problem vermieden wird, aber ist es unbekannte Probleme (für mich) in Bezug auf das?

Answer 1

Es gibt keine Probleme mit der zweiten Version des Zuweisungsoperators. In der Tat ist das der Standard für einen Zuweisungsoperator.

Bearbeiten: Beachten Sie, dass ich auf den Rückgabetyp des Zuweisungsoperators beziehen, nicht auf die Implementierung selbst. Wie in den Kommentaren erwähnt wurde, ist die Implementierung selbst ein anderes Thema. Siehe here.

Answer 2

Die zweite ist ziemlich Standard. Oft ziehen Sie es vor, eine Referenz von einem Zuweisungsoperator zurückzugeben, damit Anweisungen wie a = b = c; wie erwartet aufgelöst werden. Ich kann mir keine Fälle vorstellen, in denen ich eine Kopie vom Auftrag zurückgeben möchte.

Eine Sache zu beachten ist, dass, wenn Sie keine tiefe Kopie benötigen, es manchmal am besten ist, den impliziten Kopierkonstruktor und den Zuweisungsoperator zu verwenden, der vom Compiler erzeugt wird, als Ihren eigenen zu rollen. Wirklich an Ihnen aber ...

Edit:

Hier einige grundlegende Anrufe:

SimpleCircle x; // default constructor 
SimpleCircle y(x); // copy constructor 
x = y; // assignment operator 

Nun sagen wir die erste Version des Zuweisungsoperator hatte:

SimpleCircle SimpleCircle::operator=(const SimpleCircle & rhs) 
{ 
    if(this == &rhs) 
     return *this; // calls copy constructor SimpleCircle(*this) 
    itsRadius = rhs.getRadius(); // copy member 
    return *this; // calls copy constructor 
} 

Es ruft den Kopierkonstruktor auf und übergibt eine Referenz an this, um die Kopie zu erstellen, die zurückgegeben werden soll. Jetzt im zweiten Beispiel vermeiden wir die Kopie nur durch einen Verweis auf this

SimpleCircle & SimpleCircle::operator=(const SimpleCircle & rhs) 
{ 
    if(this == &rhs) 
     return *this; // return reference to this (no copy) 
    itsRadius = rhs.getRadius(); // copy member 
    return *this; // return reference to this (no copy) 
} 

Answer 3

Unter den Umständen der Rückkehr, sind Sie fast sicher besser die Prüfung für Selbstzuordnung Überspringen - wenn Sie nur eine Zuordnung Element, das es als vermeiden ein einfacher Typ (wahrscheinlich ein Doppelzimmer), ist es im allgemeinen schneller zu tun, dass die Zuordnung zu sein scheint, so würden Sie am Ende mit:

SimpleCircle & SimpleCircle::operator=(const SimpleCircle & rhs) 
{ 
    itsRadius = rhs.getRadius(); // or just `itsRadius = rhs.itsRadius;` 
    return *this; 
} 

ich weiß, dass viele ältere und/oder geringere Qualität Bücher raten zur Selbstüberprüfung. Zumindest ist es meiner Erfahrung nach jedoch selten genug, dass es ohne sie besser geht (und wenn der Operator von der Korrektheit abhängt, ist es fast sicher nicht ausnahmslos sicher).

Als Nebenbemerkung würde ich bemerken, dass Sie zum Definieren eines Kreises in der Regel einen Mittelpunkt und einen Radius benötigen, und wenn Sie kopieren oder zuweisen, möchten Sie beide kopieren/zuweisen.

Answer 4

es ist richtige Weise, Operator Überladung zu verwenden jetzt erhalten Sie Ihr Objekt durch Referenz vermeiden Wert kopieren.

Answer 5

könnte dies nützlich sein:

// Operator overloading in C++ 
//assignment operator overloading 
#include<iostream> 
using namespace std; 

class Employee 
{ 
private: 
int idNum; 
double salary; 
public: 
Employee () { 
    idNum = 0, salary = 0.0; 
} 

void setValues (int a, int b); 
void operator= (Employee &emp); 

}; 

void Employee::setValues (int idN , int sal) 
{ 

salary = sal; idNum = idN; 

} 

void Employee::operator = (Employee &emp) // Assignment operator overloading function 
{ 
salary = emp.salary; 
} 

int main () 
{ 

Employee emp1; 
emp1.setValues(10,33); 
Employee emp2; 
emp2 = emp1; // emp2 is calling object using assignment operator 

}