C++
Kopiering vs uppdrag

Syntax

• Kopiera konstruktör
• MyClass (const MyClass & andra);
• MyClass (MyClass & andra);
• MyClass (flyktig const MyClass & andra);
• MyClass (flyktiga MyClass & andra);
• Uppdragskonstruktör
• 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 operatör = (const MyClass & rhs);
• MyClass operatör = (MyClass & rhs);
• MyClass operatör = (MyClass rhs);

parametrar

Anmärkningar

Uppdragsoperatör

Uppdragsoperatören är när du ersätter data med ett redan befintligt (tidigare initialiserat) objekt med vissa andra objekts data. Låt oss ta detta som ett exempel:

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

Du kan se här jag ringer tilldelningsoperatören när jag redan initierade foo objektet. Senare tilldelar jag foo2 till foo . Alla ändringar som ska visas när du ringer samma operatör av lika tecken definieras i din operator= funktion. Du kan se en körbar utgång här: http://cpp.sh/3qtbm

Kopiera konstruktör

Kopieringskonstruktör å andra sidan är det motsatta av uppdragskonstruktören. Den här gången används det för att initialisera ett redan obefintligt (eller icke-initialiserat) objekt. Det betyder att den kopierar all data från objektet du tilldelar den till, utan att faktiskt initialisera objektet som kopieras till. Låt oss nu titta på samma kod som tidigare men ändra uppdragskonstruktören till att vara en kopieringskonstruktör:

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

Här kan du se Foo foo2 = foo; i huvudfunktionen tilldelar jag omedelbart objektet innan jag faktiskt initierar det, vilket som sagt tidigare betyder att det är en kopieringskonstruktör. Och märker att jag inte behövde passera parametern int för foo2 objektet eftersom jag automatiskt drog tidigare data från objektet foo. Här är ett exempel på utdata: http://cpp.sh/5iu7

Kopiera konstruktör Vs uppdrag konstruktör

OK, vi har kort tittat över vad kopieringskonstruktören och uppdragskonstruktören är ovan och gav exempel på var och en nu, låt oss se båda i samma kod. Den här koden kommer att likna ovanstående två. Låt oss ta detta:

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

Produktion:

2
2

Här kan du se att vi först kallar kopieringskonstruktören genom att utföra linjen Foo foo2 = foo; . Eftersom vi inte initialiserade det tidigare. Och sedan nästa kallar vi uppdragsoperatören på foo3 eftersom det redan initierades foo3=foo ;