Liste de contrôle pour rédiger le constructeur de copie et l'opérateur d'affectation en C ++

Question

Veuillez rédiger une liste de tâches qu'un constructeur de copie et un opérateur d'affectation doivent effectuer en C ++ pour préserver la sécurité des exceptions, éviter les fuites de mémoire, etc.

Answer 1

Tout d’abord, assurez-vous que vous avez vraiment besoin de prendre en charge la copie. La plupart du temps, ce n’est pas le cas, et par conséquent, il est impératif de les désactiver.

Parfois, vous devez toujours fournir une duplication sur une classe à partir d'une hiérarchie polymorphe. Dans ce cas, désactivez l'opérateur d'affectation, écrivez un constructeur de copie (protected?) et fournissez une fonction de clone () virtuel.

Sinon, si vous écrivez une classe de valeur, vous revenez au pays de la forme canonique orthogonale de Coplien. Si vous avez un membre qui ne peut pas être copié de manière triviale, vous devez fournir un constructeur de copie, un destructeur, un opérateur d'affectation et un constructeur par défaut. Cette règle peut être affinée, voir par exemple: La loi des deux grands

Je recommanderais également de consulter FAQ C ++ sur les opérateurs d'affectation , et à la idiome copier-échanger et sur GOTW .

Answer 2

Les versions générées par le compilateur fonctionnent dans la plupart des situations.

Vous devez réfléchir un peu plus au problème lorsque votre objet contient un pointeur RAW (un argument pour ne pas avoir de pointeur RAW). Donc, vous avez un pointeur RAW, la deuxième question est vous possédez le pointeur (est-il en train d'être supprimé par vous)? Si tel est le cas, vous devrez appliquer la règle de 4.

Posséder plus d'un pointeur RAW devient de plus en plus difficile à réaliser correctement (la complexité ne devient pas non plus linéaire [mais c'est une observation et je n'ai aucune statistique à l'appui pour appuyer cette affirmation]). Donc, si vous avez plus d’un pointeur RAW, pensez à en insérer chacun dans sa propre classe (une sorte de pointeur intelligent).

Règle de 4: si un objet est le propriétaire d'un pointeur RAW, vous devez définir les 4 membres suivants pour vous assurer de gérer correctement la gestion de la mémoire:

• constructeur
• Constructeur de copie
• Opérateur d'affectation
• Destructor

La façon dont vous définissez cela dépendra des situations. Mais il faut faire attention:

• Construction par défaut: définissez le pointeur sur NULL
• Constructeur de copie: utilisez les options Copie et échange pour fournir à la "Garantie d’exception forte"
.
• Opérateur d'affectation: recherchez l'affectation à vous-même
• Destructor: protège contre les exceptions se propageant hors du destructeur.

Answer 3

essayez de lire ceci.

http://www.icu-project.org/docs /papers/cpp_report/the_anatomy_of_the_assignment_operator.html

est une très bonne analyse de l'opérateur d'affectation

Answer 4

Je n'ai aucune idée de l'exception en toute sécurité ici, mais je vais dans cette direction. Imaginons qu'il s'agisse d'un wrapper de tableau basé sur un modèle. J'espère que ça aide:)

Array(const Array& rhs)
    {
        mData = NULL;
        mSize = rhs.size();
        *this = rhs;
    }

    Array& operator=(const Array& rhs)
    {
        if(this == &rhs)
        {
            return *this;
        }

        int len = rhs.size();

        delete[] mData;

        mData = new T[len];

        for(int i = 0; i < len; ++i)
        {
            mData[i] = rhs[i];
        }

        mSize = len;

        return *this;
    }