C++
Copier vs assignation

Syntaxe

• Constructeur de copie
• MyClass (const MyClass & other);
• MyClass (MyClass & other);
• MyClass (volatil const MyClass et autres);
• MyClass (volatile MyClass et autres);
• Constructeur d'affectation
• 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);
• Opérateur MyClass = (const MyClass & rhs);
• Opérateur MyClass = (MyClass & rhs);
• MyClass operator = (MyClass rhs);

Paramètres

Remarques

Opérateur d'assignation

L'opérateur d'affectation est lorsque vous remplacez les données par un objet déjà existant (précédemment initialisé) par d'autres données d'objet. Prenons ceci comme exemple:

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

Vous pouvez voir ici que j'appelle l'opérateur d'assignation lorsque j'ai déjà initialisé l'objet foo . Ensuite, foo2 à foo . Toutes les modifications à afficher lorsque vous appelez cet opérateur de signe égal sont définies dans votre fonction operator= . Vous pouvez voir une sortie exécutable ici: http://cpp.sh/3qtbm

Constructeur de copie

Le constructeur de copie, par contre, est l’opposé complet du constructeur d’affectation. Cette fois, il est utilisé pour initialiser un objet déjà inexistant (ou non précédemment initialisé). Cela signifie qu'il copie toutes les données de l'objet auquel vous les affectez, sans pour autant initialiser l'objet sur lequel il est copié. Maintenant, regardons le même code que précédemment, mais modifions le constructeur d'affectation pour qu'il devienne un constructeur de 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;
}

Vous pouvez voir ici Foo foo2 = foo; dans la fonction principale, j'attribue immédiatement l'objet avant de l'initialiser, ce qui signifie que c'est un constructeur de copie. Et notez que je n’ai pas eu besoin de passer le paramètre int pour l’objet foo2 car j’ai automatiquement tiré les données précédentes de l’objet foo. Voici un exemple de sortie: http://cpp.sh/5iu7

Constructeur de constructeur Vs Assignment Construct

Ok, nous avons brièvement regardé ce que le constructeur de copie et le constructeur d’affectation sont au-dessus et nous avons donné des exemples de chacun maintenant, voyons les deux dans le même code. Ce code sera similaire à ci-dessus deux. Prenons ceci:

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

Sortie:

2
2

Ici, vous pouvez voir que nous appelons d'abord le constructeur de copie en exécutant la ligne Foo foo2 = foo; . Puisque nous ne l'avons pas initialisé auparavant. Et ensuite nous appelons l'opérateur d'affectation sur foo3 car il était déjà initialisé foo3=foo ;