C++
Kopiëren versus toewijzing

Syntaxis

• Kopieer Constructor
• MyClass (const MyClass & other);
• MyClass (MyClass & other);
• MyClass (volatile const MyClass & other);
• MyClass (vluchtig MyClass en andere);
• Opdracht Constructor
• 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);
• MyClass-operator = (const MyClass & rhs);
• MyClass-operator = (MyClass & rhs);
• MyClass-operator = (MyClass rhs);

parameters

Opmerkingen

Opdracht Operator

De Assignment Operator is wanneer u de gegevens vervangt door een reeds bestaand (eerder geïnitialiseerd) object door gegevens van een ander object. Laten we dit als voorbeeld nemen:

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

Je kunt hier zien dat ik de toewijzingsoperator roepte toen ik het foo object al initialiseerde. Later wijs ik foo2 aan foo . Alle wijzigingen die worden weergegeven wanneer u die operator voor gelijkteken roept, zijn gedefinieerd in uw operator= -functie. U kunt hier een uitvoerbare uitvoer zien: http://cpp.sh/3qtbm

Kopieer Constructor

Kopieer de constructor daarentegen is het tegenovergestelde van de Assignment Constructor. Deze keer wordt het gebruikt om een al niet-bestaand (of niet-eerder geïnitialiseerd) object te initialiseren. Dit betekent dat alle gegevens worden gekopieerd van het object waaraan u het toewijst, zonder het object waarnaar wordt gekopieerd, te initialiseren. Laten we nu eens naar dezelfde code kijken als eerder, maar de toewijzingsconstructor wijzigen in een kopieconstructor:

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

Je kunt hier zien Foo foo2 = foo; in de hoofdfunctie wijs ik het object onmiddellijk toe voordat het daadwerkelijk wordt geïnitialiseerd, wat zoals eerder gezegd betekent dat het een copyconstructor is. En merk op dat ik de parameter int voor het foo2 object niet hoefde door te geven, omdat ik automatisch de vorige gegevens van het object foo heb opgehaald. Hier is een voorbeelduitvoer: http://cpp.sh/5iu7

Kopieer Constructor Vs Assignment Constructor

Ok, we hebben kort bekeken wat de copyconstructor en de opdrachtconstructor hierboven zijn en hebben voorbeelden gegeven van elk laten we ze nu in dezelfde code bekijken. Deze code is vergelijkbaar met bovenstaande twee. Laten we dit nemen:

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

Output:

2
2

Hier kun je zien dat we eerst de copy constructor aanroepen door de regel Foo foo2 = foo; . Omdat we het niet eerder hebben geïnitialiseerd. En vervolgens roepen we de toewijzingsoperator op foo3 aan, omdat deze al geïnitialiseerd is foo3=foo ;