C++
Copia vs Assegnazione

Sintassi

• Copia il costruttore
• MyClass (const MyClass e altro);
• MyClass (MyClass e altro);
• MyClass (volatile const MyClass e altro);
• MyClass (volatile MyClass e altro);
• Costruttore di assegnazione
• MyClass & operator = (const MyClass & rhs);
• MyClass & operator = (MyClass & rhs);
• MyClass & operator = (MyClass rhs);
• const MyClass & operator = (const MyClass & rhs);
• const MyClass & operator = (MyClass & rhs);
• const MyClass & operator = (MyClass rhs);
• Operatore MyClass = (const MyClass & rhs);
• Operatore MyClass = (MyClass & rhs);
• Operatore MyClass = (MyClass rhs);

Parametri

Osservazioni

Operatore di assegnazione

L'Operatore di assegnazione è quando si sostituiscono i dati con un oggetto già esistente (precedentemente inizializzato) con alcuni dati di altri oggetti. Prendiamo questo come esempio:

// Assignment Operator
#include <iostream>
#include <string>

using std::cout;
using std::endl;

class Foo
{
  public:
    Foo(int data)
    {
        this->data = data;    
    }
    ~Foo(){};
    Foo& operator=(const Foo& rhs)
    {
            data = rhs.data; 
            return *this;
    }

    int data;
};

int main()
{
   Foo foo(2); //Foo(int data) called
   Foo foo2(42);
   foo = foo2; // Assignment Operator Called
   cout << foo.data << endl; //Prints 42
}

Potete vedere qui chiamo l'operatore di assegnazione quando ho già inizializzato l'oggetto foo . Poi più tardi assegnerò foo2 a foo . Tutte le modifiche da visualizzare quando si chiama quell'operatore con segno di uguale sono definite nella funzione operator= . Puoi vedere un output eseguibile qui: http://cpp.sh/3qtbm

Copia il costruttore

Copia costruttore d'altra parte, è l'esatto opposto del Costruttore di assegnazione. Questa volta, viene utilizzato per inizializzare un oggetto già inesistente (o non precedentemente inizializzato). Ciò significa che copia tutti i dati dall'oggetto a cui lo si sta assegnando, senza in realtà inizializzare l'oggetto su cui si sta copiando. Ora diamo un'occhiata allo stesso codice di prima, ma modifichiamo il costruttore di assegnamenti per essere un costruttore di copie:

// Copy Constructor
#include <iostream>
#include <string>

using std::cout;
using std::endl;

class Foo
{
  public:
    Foo(int data)
    {
        this->data = data;    
    }
    ~Foo(){};
    Foo(const Foo& rhs)
    {
            data = rhs.data; 
    }

    int data;
};

int main()
{
   Foo foo(2); //Foo(int data) called
   Foo foo2 = foo; // Copy Constructor called
   cout << foo2.data << endl;
}

Puoi vedere qui Foo foo2 = foo; nella funzione principale assegno immediatamente l'oggetto prima di inizializzarlo effettivamente, cosa che come detto prima significa che è un costruttore di copie. E notate che non ho bisogno di passare il parametro int per l'oggetto foo2 dato che ho tirato automaticamente i dati precedenti dall'oggetto foo. Ecco un esempio di output: http://cpp.sh/5iu7

Copia Costruttore Assegnazione Vs Costruttore

Ok, abbiamo esaminato brevemente cosa sono sopra il costruttore di copie e il costruttore di assegnamenti e abbiamo fornito esempi di ciascuno di essi, ora vediamo entrambi nello stesso codice. Questo codice sarà simile come sopra due. Prendiamo questo:

// Copy vs Assignment Constructor
#include <iostream>
#include <string>

using std::cout;
using std::endl;

class Foo
{
  public:
    Foo(int data)
    {
        this->data = data;    
    }
    ~Foo(){};
    Foo(const Foo& rhs)
    {
            data = rhs.data; 
    }

    Foo& operator=(const Foo& rhs)
    {
        data = rhs.data; 
        return *this;
    }

    int data;
};

int main()
{
   Foo foo(2); //Foo(int data) / Normal Constructor called
   Foo foo2 = foo; //Copy Constructor Called
   cout << foo2.data << endl;

   Foo foo3(42);
   foo3=foo; //Assignment Constructor Called
   cout << foo3.data << endl;
}

Produzione:

2
2

Qui puoi vedere che prima chiamiamo il costruttore di copie eseguendo la riga Foo foo2 = foo; . Dal momento che non l'abbiamo inizializzato in precedenza. E poi chiamiamo l'operatore di assegnazione su foo3 poiché era già inizializzato foo3=foo ;