Le constructeur de copie et l'opérateur d'affectation

Question

Si je remplace operator=, le constructeur de copie utilisera-t-il automatiquement le nouvel opérateur ? De même, si je définis un constructeur de copie, operator= 'héritera'-t-il automatiquement du comportement du constructeur de copie ?

Answer 1

Non, ce sont des opérateurs différents.

Le constructeur de copie sert à créer un nouvel objet. Il copie un objet existant vers un objet nouvellement construit. Le constructeur de copie est utilisé pour initialiser une nouvelle instance à partir d'une ancienne instance. Il n'est pas nécessairement appelé lors du passage de variables par valeur dans les fonctions ou en tant que valeurs de retour des fonctions.

L'opérateur d'attribution permet de gérer un objet déjà existant. L'opérateur d'attribution est utilisé pour modifier une instance existante afin qu'elle ait les mêmes valeurs que l'opérande droit, ce qui signifie que l'instance doit être détruite et réinitialisée si elle possède une mémoire dynamique interne.

Lien utile :

• Constructeurs de copie, opérateurs d'affectation, et plus encore
• Constructeur de copie et surcharge de l'opérateur = en C++ : une fonction commune est-elle possible ?

Answer 2

Non. Sauf si vous définissez un constructeur de copie, un constructeur par défaut sera généré (si nécessaire). Sauf si vous définissez un opérateur=, un opérateur par défaut sera généré (si nécessaire). Ils ne se servent pas mutuellement, et vous pouvez les modifier indépendamment.

Answer 3

Non. Ce sont des objets différents.

Si votre préoccupation est la duplication de code entre le constructeur de copie et l'opérateur d'assignation, envisagez l'idiome suivant, nommé copier et échanger :

struct MyClass
{
    MyClass(const MyClass&); // Implémenter la logique de copie ici
    void swap(MyClass&) throw(); // Implémenter un échange léger ici (par exemple, échanger des pointeurs)

    MyClass& operator=(MyClass x)
    {
        x.swap(*this);
        return *this;
    }
};

De cette façon, l'opérateur= utilisera le constructeur de copie pour construire un nouvel objet, qui sera échangé avec *this et libéré (avec l'ancien this à l'intérieur) à la sortie de la fonction.

Answer 4

Non.

Et jetez certainement un coup d'œil à la règle de trois (ou règle de cinq en tenant compte des rvalues)

Answer 5

Considérez le programme C++ suivant.
Note: Ma classe "Vector" n'est pas celle de la bibliothèque standard.
Interface de ma classe "Vector":

#include 

class Vector {
private:
    double* elem; // elem pointe vers un tableau de doubles de taille sz
    int sz;
public:
    Vector(int s);  // constructeur : acquérir des ressources
    ~Vector() { delete[] elem; }   // destructeur : libérer des ressources
    Vector(const Vector& a);               // constructeur de copie
    Vector& operator=(const Vector& a);    // opérateur d'assignation de copie
    double& operator[](int i){ return elem[i]; };
    int size() const {return sz;};
};

Implémentation des membres de ma classe "Vector":

Vector::Vector(int s)  // constructeur non-défaut
{
    std::cout << "constructeur non-défaut"<