la "règle des trois est une règle empirique pour C++, qui dit essentiellement

si votre classe a besoin de

• un constructeur de copie ,
• un opérateur d'affectation ,
• ou un destructeur ,

défini explicitement, alors il est probablement besoin de tous les trois .

Les raisons pour cela est que tous les trois d'entre eux sont généralement utilisés pour gérer une ressource, et si votre classe gère une ressource, il est généralement nécessaire de gérer la copie libérer.

S'il n'y a pas de bonne sémantique pour copier la ressource gérée par votre classe, alors envisagez d'interdire la copie en déclarant (pas définir ) le constructeur de copie et l'opérateur d'affectation private .

(notez que la nouvelle version à venir de la norme C++ (qui est C++11) ajoute la sémantique de déplacement à C++, ce qui va probablement changer la règle de trois. Cependant, j'en sais trop peu pour écrire une section C++11 sur la règle des trois.)

la loi des trois grands est comme indiqué ci-dessus.

un exemple facile, en anglais simple, du genre de problème qu'il résout:

Non destructeur par défaut

vous avez alloué de la mémoire dans votre constructeur et vous devez donc écrire un destructeur pour le supprimer. Sinon, vous causerez une fuite de mémoire.

Vous pourriez penser que c'est du travail fait.

le le problème sera, si une copie de votre objet, puis la copie de point à la même mémoire que l'objet d'origine.

une fois, l'un d'eux supprime la mémoire dans son destructeur, l'autre aura un pointeur vers la mémoire invalide (ceci est appelé un pointeur pendulaire) quand il essaie de l'utiliser les choses vont devenir velues.

donc, vous écrivez un constructeur de copie de sorte qu'il attribue de nouveaux objets de leurs propres pièces de mémoire à détruire.

opérateur d'Affectation et de constructeur de copie

vous avez attribué de la mémoire dans votre constructeur à un pointeur membre de votre classe. Lorsque vous copiez un objet de cette classe, l'opérateur de tâche par défaut et le constructeur de copie copient la valeur de ce pointeur de membre vers le nouvel objet.

cela signifie que le nouvel objet et l'ancien objet seront dirigés vers le même morceau de mémoire donc quand vous le Changez Dans un objet il sera changé pour l'autre objerct aussi. Si un objet efface cette mémoire l'autre continuera à essayer de l'utiliser - eek.

pour résoudre ceci vous écrivez votre propre version du constructeur de copie et de l'opérateur d'affectation. Vos versions attribuent une mémoire séparée aux nouveaux objets et copient à travers les valeurs que le premier pointeur pointe plutôt que son adresse.

essentiellement si vous avez un destructeur (pas le destructeur par défaut) cela signifie que la classe que vous avez définie a une certaine allocation de mémoire. Supposons que la classe soit utilisée à l'extérieur par un code client ou par vous.

    MyClass x(a, b);
    MyClass y(c, d);
    x = y; // This is a shallow copy if assignment operator is not provided

si MyClass n'a que quelques membres tapés primitifs, un opérateur d'affectation par défaut fonctionnerait, mais s'il a des membres pointeurs et des objets qui n'ont pas d'opérateurs d'affectation, le résultat serait imprévisible. Nous pouvons donc dire que si il y a quelque chose à supprimer dans destructor d'une classe, nous pourrions avoir besoin d'un opérateur de copie profonde, ce qui signifie que nous devrions fournir un constructeur de copie et un opérateur de tâche.

que signifie copier un objet? Il y a quelques façons de copier des objets--parlons des deux types auxquels vous faites très probablement référence--la copie profonde et la copie superficielle.

puisque nous sommes dans un langage orienté objet (ou du moins le présumons), disons que vous avez un morceau de mémoire alloué. Puisqu'il s'agit d'un langage OO, nous pouvons facilement faire référence à des morceaux de mémoire que nous attribuons parce qu'ils sont généralement des variables primitives (ints, chars, octets) ou des classes que nous avons définies. qui sont faits de nos propres types et primitives. Donc, disons que nous avons une classe de voiture comme suit:

class Car //A very simple class just to demonstrate what these definitions mean.
//It's pseudocode C++/Javaish, I assume strings do not need to be allocated.
{
private String sPrintColor;
private String sModel;
private String sMake;

public changePaint(String newColor)
{
   this.sPrintColor = newColor;
}

public Car(String model, String make, String color) //Constructor
{
   this.sPrintColor = color;
   this.sModel = model;
   this.sMake = make;
}

public ~Car() //Destructor
{
//Because we did not create any custom types, we aren't adding more code.
//Anytime your object goes out of scope / program collects garbage / etc. this guy gets called + all other related destructors.
//Since we did not use anything but strings, we have nothing additional to handle.
//The assumption is being made that the 3 strings will be handled by string's destructor and that it is being called automatically--if this were not the case you would need to do it here.
}

public Car(const Car &other) // Copy Constructor
{
   this.sPrintColor = other.sPrintColor;
   this.sModel = other.sModel;
   this.sMake = other.sMake;
}
public Car &operator =(const Car &other) // Assignment Operator
{
   if(this != &other)
   {
      this.sPrintColor = other.sPrintColor;
      this.sModel = other.sModel;
      this.sMake = other.sMake;
   }
   return *this;
}

}

une copie profonde est si nous déclarons un objet et créons alors une copie complètement séparée de l'objet...nous nous retrouvons avec 2 objets dans 2 complètement de la mémoire.

Car car1 = new Car("mustang", "ford", "red");
Car car2 = car1; //Call the copy constructor
car2.changePaint("green");
//car2 is now green but car1 is still red.

maintenant, faisons quelque chose d'étrange. Disons que les personnages car2 est soit mal programmée ou délibérément faits pour partager la mémoire réelle car1. (Il est généralement une erreur de faire cela et dans les classes est généralement la couverture, il est discuté sous. Prétendez que chaque fois que vous posez des questions sur car2, vous résolvez vraiment un pointeur vers l'espace mémoire de car1...c'est plus ou moins ce qu'est une copie superficielle est.

//Shallow copy example
//Assume we're in C++ because it's standard behavior is to shallow copy objects if you do not have a constructor written for an operation.
//Now let's assume I do not have any code for the assignment or copy operations like I do above...with those now gone, C++ will use the default.

 Car car1 = new Car("ford", "mustang", "red"); 
 Car car2 = car1; 
 car2.changePaint("green");//car1 is also now green 
 delete car2;/*I get rid of my car which is also really your car...I told C++ to resolve 
 the address of where car2 exists and delete the memory...which is also
 the memory associated with your car.*/
 car1.changePaint("red");/*program will likely crash because this area is
 no longer allocated to the program.*/

donc, peu importe la langue dans laquelle vous écrivez, faites très attention à ce que vous voulez dire quand il s'agit de copier des objets parce que la plupart du temps vous voulez une copie profonde.

Qu'est-ce que le constructeur de copie et le opérateur d'assignation de copie? J'ai déjà utilisé plus haut. Le constructeur de copie est appelé lorsque vous tapez un code tel que Car car2 = car1; essentiellement si vous déclarez une variable et l'assignez dans une ligne, c'est quand le constructeur de copie est appelé. L'opérateur de tâche est ce qui se passe lorsque vous utilisez un signe égal-- car2 = car1; . L'avis car2 n'est pas déclaré dans la même déclaration. Les deux morceaux de code que vous écrivez pour ces opérations sont probablement très similaire. En fait, le design typique pattern a une autre fonction que vous appelez pour tout régler une fois que vous êtes convaincu que la copie/assignation initiale est légitime--si vous regardez le code à la main que j'ai écrit, les fonctions sont presque identiques.

Quand dois-je déclarer moi-même? Si vous n'écrivez pas le code qui doit être partagé ou pour la production d'une certaine manière, vous n'avez vraiment besoin de les déclarer que lorsque vous en avez besoin. Vous devez être conscient de ce que fait votre langue de programme si vous choisissez de l'utiliser ' par accident et n'a pas un--c'est à dire que vous obtenez le compilateur par défaut. J'utilise rarement copie constructeurs par exemple, mais l'opérateur d'assignation de remplacements sont très fréquents. Saviez-vous que vous pouvez remplacer ce que l'addition, la soustraction, etc. dire ainsi?

Comment puis-je empêcher la copie de mes objets? Outrepasser toutes les façons dont vous êtes autorisé à allouer de la mémoire pour votre objet avec une fonction privée est un départ raisonnable. Si tu ne veux vraiment pas que les gens les copient, tu pourrais le rendre public et alerter le programmeur en lançant une exception et en ne copiant pas l'objet.

Quand dois-je déclarer moi-même?

La Règle des Trois états que si vous déclarez une

1. constructeur de copie
2. copier l'opérateur d'affectation
3. destructeur

alors vous devez déclarer les trois. Elle est née du constat que la nécessité de prendre sur la signification d'une opération de copie presque toujours

• quelle que soit la gestion des ressources effectuée dans une opération de copie, il fallait probablement le faire dans l'autre opération de copie et

• le destructeur de classe participera en outre à la gestion de la ressource (généralement de le libérer). La ressource classique à gérer était la mémoire, et ceci est pourquoi toutes les classes de bibliothèque Standard que gérer la mémoire (par exemple, les conteneurs STL qui effectuent la gestion dynamique de la mémoire) tous déclarent "les trois grands": à la fois des opérations de copie et un destructeur.

une conséquence de la règle des trois est que la présence d'un destructeur déclaré par l'utilisateur indique que la simple copie conforme à l'utilisateur est peu susceptible d'être appropriée pour les opérations de copie dans la classe. Cela, à son tour, suggère que si une classe déclare un destructeur, les opérations de copie ne devraient probablement pas être générées automatiquement, parce qu'elles ne feraient pas la bonne chose. Au moment de l'adoption de C++98, l'importance de ce raisonnement n'était pas pleinement appréciée, de sorte que dans C++98, l'existence d'un destructeur déclaré par l'utilisateur n'a eu aucun impact sur la volonté des compilateurs de générer des opérations de copie. Cela continue d'être le cas en C++11, mais seulement parce que la restriction des conditions dans lesquelles les opérations de copie sont générées ça briserait trop de code d'héritage.

Comment puis-je empêcher la copie de mes objets?

Déclarer constructeur de copie de copie et l'opérateur d'assignation comme l'accès privé spécificateur.

class MemoryBlock
{
public:

//code here

private:
MemoryBlock(const MemoryBlock& other)
{
   cout<<"copy constructor"<<endl;
}

// Copy assignment operator.
MemoryBlock& operator=(const MemoryBlock& other)
{
 return *this;
}
};

int main()
{
   MemoryBlock a;
   MemoryBlock b(a);
}

à partir de C++11, Vous pouvez également déclarer que le constructeur de copies et l'opérateur de cession ont été supprimés

class MemoryBlock
{
public:
MemoryBlock(const MemoryBlock& other) = delete

// Copy assignment operator.
MemoryBlock& operator=(const MemoryBlock& other) =delete
};


int main()
{
   MemoryBlock a;
   MemoryBlock b(a);
}

plusieurs des réponses existantes touchent déjà le constructeur de copies, l'opérateur d'affectation et le destructeur. Toutefois, après C++11, l'introduction de la sémantique move peut étendre cette possibilité au-delà de 3.

récemment, Michael Claisse a donné une conférence qui touche à ce sujet: http://channel9.msdn.com/events/CPP/C-PP-Con-2014/The-Canonical-Class

règle de trois dans C++ est un principe fondamental de la conception et le développement de trois exigences que s'il y a une définition claire dans l'une des fonctions de membre suivantes, alors le programmeur devrait définir les deux autres fonctions de membre ensemble. À savoir les trois fonctions de membre sont indispensables: destructeur, constructeur de copie, copie opérateur d'affectation.

Copy constructor en C++ est un constructeur spécial. Il est utilisé pour construire un nouveau l'objet, qui est le nouvel objet équivalent à une copie d'un objet existant.

Copier l'opérateur d'affectation est un opérateur d'affectation spéciale qui est habituellement utilisé pour spécifier un objet existant à d'autres du même type d'objet.

il y a des exemples rapides:

// default constructor
My_Class a;

// copy constructor
My_Class b(a);

// copy constructor
My_Class c = a;

// copy assignment operator
b = a;