overbelasting van de toewijzingsoperator in c++

Ik heb de volgende code gebruikt voor overbelasting van de toewijzingsoperator:

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

Mijn Copy Constructor is dit:

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

In de bovenstaande overbelastingscode van de operator wordt de kopieerconstructor aangeroepen omdat er een nieuw object wordt gemaakt; daarom heb ik de onderstaande code gebruikt:

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

Het werkt perfect en het kopieerconstructor-probleem wordt vermeden, maar zijn er onbekende problemen (voor mij) met betrekking tot dit ?

Antwoord 1, autoriteit 100%

Er zijn geen problemen met de tweede versie van de toewijzingsoperator. In feite is dat de standaardmanier voor een toewijzingsoperator.

Bewerken: merk op dat ik verwijs naar het retourtype van de toewijzingsoperator, niet naar de implementatie zelf. Zoals in opmerkingen is opgemerkt, is de implementatie zelf een ander probleem. Zie hier.

Antwoord 2, autoriteit 40%

De tweede is vrij standaard. U geeft vaak de voorkeur aan retourneren van een referentie van een toewijzingsoperator, zodat uitspraken als a = b = c;RESOLOSEN zoals verwacht. Ik kan geen gevallen bedenken waarin ik een kopie van opdracht wil retourneren.

Eén ding om op te merken is dat als u geen diepe kopie nodig heeft, het soms als het beste wordt beschouwd om de impliciete kopieerconstructeur- en toewijzingsoperator te gebruiken die door de compiler wordt gegenereerd dan die van uzelf rollen. Echt aan jou …

bewerken:

Hier is enkele basisoproepen:

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

Zeg nu dat we de eerste versie van uw opdrachtoperator hadden:

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
}

Het roept de Copy Constructor aan en geeft een verwijzing naar thisom het te bouwen exemplaar te construeren. Nu in het tweede voorbeeld vermijden we het exemplaar door gewoon een verwijzing naar this

te retourneren

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)
}

Antwoord 3, Autoriteit 35%

Onder de gegeven omstandigheden kun je de controle voor zelftoewijzing vrijwel zeker beter overslaan — als je slechts één lid toewijst dat een eenvoudig type lijkt te zijn (waarschijnlijk een dubbel), is het over het algemeen sneller om dat te doen opdracht dan vermijden, zodat je zou eindigen met:

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

Ik realiseer me dat veel oudere boeken en/of boeken van lagere kwaliteit adviseren om te controleren op zelftoewijzing. Mijn ervaring is echter dat het zelden voorkomt dat u beter af bent zonder (en als de operator er voor de juistheid van afhankelijk is, is het vrijwel zeker niet uitzonderlijk veilig).

Terzijde wil ik opmerken dat om een cirkel te definiëren, je over het algemeen een middelpunt en een straal nodig hebt, en als je kopieert of toewijst, wil je beide kopiëren/toewijzen.

Antwoord 4, autoriteit 5%

#include<iostream>
using namespace std;
class employee
{
    int idnum;
    double salary;
    public:
        employee(){}
        employee(int a,int b)
        {
            idnum=a;
            salary=b;
        }
        void dis()
        {
            cout<<"1st emp:"<<endl<<"idnum="<<idnum<<endl<<"salary="<<salary<<endl<<endl;
        }
        void operator=(employee &emp)
        {
            idnum=emp.idnum;
            salary=emp.salary;
        }
        void show()
        {
            cout<<"2nd emp:"<<endl<<"idnum="<<idnum<<endl<<"salary="<<salary<<endl;
        }
};
main()
{
    int a;
    double b;
    cout<<"enter id num and salary"<<endl;
    cin>>a>>b;
    employee e1(a,b);
    e1.dis();
    employee e2;
    e2=e1;
    e2.show();  
}

Antwoord 5

Het is de juiste manier om operator overbelasting te gebruiken
Nu krijg je je object door verwijzing
Value-kopiëren vermijden.

Antwoord 6

Dit kan nuttig zijn:

// 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
}