C++
Kopieren vs Zuordnung

Syntax

• Konstruktor kopieren
• MyClass (const MyClass und andere);
• MyClass (MyClass und andere);
• MyClass (volatile const MyClass und andere);
• MyClass (volatile MyClass und andere);
• Zuweisungskonstruktor
• MyClass & operator = (const MyClass & rhs);
• MeineKlasse & operator = (MeineKlasse & rhs);
• MyClass & operator = (MyClass rhs);
• const MyClass & operator = (const MyClass & rhs);
• const MyClass & operator = (MyClass & rhs);
• const MyClass & operator = (MyClass rhs);
• MyClass-Operator = (const MyClass & rhs);
• MyClass-Operator = (MyClass & rhs);
• MyClass-Operator = (MyClass rhs);

Parameter

Bemerkungen

Aufgabenverwalter

Der Zuweisungsoperator ist, wenn Sie die Daten durch ein bereits vorhandenes (zuvor initialisiertes) Objekt durch die Daten eines anderen Objekts ersetzen. Nehmen wir das als Beispiel:

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

Sie sehen hier, dass ich den Zuweisungsoperator anrufe, wenn ich das foo Objekt bereits initialisiert habe. Später dann ordne ich foo2 foo . Alle Änderungen, die angezeigt werden sollen, wenn Sie den Gleichheitszeichenoperator aufrufen, sind in der Funktion operator= definiert. Eine ausführbare Ausgabe finden Sie hier: http://cpp.sh/3qtbm

Konstruktor kopieren

Copy-Konstruktor hingegen ist das komplette Gegenteil des Zuweisungskonstruktors. Dieses Mal wird es verwendet, um ein bereits nicht vorhandenes (oder nicht zuvor initialisiertes) Objekt zu initialisieren. Das bedeutet, dass alle Daten des Objekts, dem Sie es zuweisen, kopiert werden, ohne dass das Objekt, auf das kopiert wird, tatsächlich initialisiert wird. Sehen wir uns nun den gleichen Code wie zuvor an, ändern Sie jedoch den Zuweisungskonstruktor als Kopierkonstruktor:

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

Sie können hier sehen Foo foo2 = foo; In der Hauptfunktion weise ich das Objekt sofort zu, bevor es tatsächlich initialisiert wird. Dies bedeutet, wie bereits gesagt, ein Kopierkonstruktor. foo2 , dass ich den Parameter int nicht für das Objekt foo2 , da ich automatisch die vorherigen Daten aus dem Objekt foo foo2 . Hier ist eine Beispielausgabe: http://cpp.sh/5iu7

Copy Constructor Vs Zuweisungskonstruktor

Ok, wir haben kurz nachgeschaut, was der Kopierkonstruktor und der Zuweisungskonstruktor oben sind, und es wurden jeweils Beispiele gegeben. Lassen Sie uns beide im gleichen Code sehen. Dieser Code ist ähnlich wie oben. Nehmen wir das an:

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

Ausgabe:

2
2

Hier sehen Sie, dass wir zuerst den Copy-Konstruktor aufrufen, indem Sie die Zeile Foo foo2 = foo; ausführen Foo foo2 = foo; . Da wir es vorher nicht initialisiert haben. Und dann rufen wir als Nächstes den Zuweisungsoperator auf foo3 auf, da er bereits initialisiert wurde foo3=foo ;