C++ Girl
  1. C++ Girl
  3. Opérateur d’affectation avec des membres de référence
Intereting Posts
Remplir un vecteur avec des nombres aléatoires c ++ Comment démarrer un nouveau projet CUDA dans Visual Studio 2008? Reliure structurée largeur Constructeur utilisant std :: forward Conteneur pour les pointeurs vers les fonctions membres avec des arguments différents Destructeurs et noexcept C ++ Initialiser un membre de données statique de classe Comment la lecture de fichier avec les boucles while fonctionne-t-elle en C ++? Multiplication efficace des quaternions C ++ avec cv :: Mat Prolongation de la durée de vie d’un object temporaire à l’aide de la référence const Ouverture d’un stream de fichier de sortie binary sans troncature Convertir “ce” pointeur en chaîne Lib et DLL liés à une erreur exe “ne peut pas lire à 0x300” Pourquoi existe-t-il des suspensions WSA pour socket (), connect (), send () etc., mais pas pour closesocket ()? Fonction to Lambda

Opérateur d’affectation avec des membres de référence

Est-ce un moyen valide de créer un opérateur d’affectation avec des membres qui sont des références? 

#include  struct A { int &ref; A(int &Ref) : ref(Ref) { } A(const A &second) : ref(second.ref) { } A &operator =(const A &second) { if(this == &second) return *this; this->~A(); new(this) A(second); return *this; } }

Il semble comstackr et fonctionner correctement, mais avec c ++ tendance à faire surface au moins indéfini, et à tous ceux qui disent que c’est impossible, un comportement indéfini, je pense que certains m’ont manqué. Est-ce que j’ai manqué quelque chose?

C’est syntaxiquement correct. Cependant, si le placement effectue de nouveaux jets, vous vous retrouvez avec un object que vous ne pouvez pas détruire. Sans parler du désastre si quelqu’un vient de votre classe. Juste ne le fais pas.

La solution est simple: si la classe a besoin de supporter une affectation, n’utilisez aucun membre de référence. J’ai beaucoup de classes qui prennent des arguments de référence, mais les stockent en tant que pointeurs, juste pour que la classe puisse supporter les assignations. Quelque chose comme: 

 struct A { int* myRef; A( int& ref ) : myRef( &ref ) {} // ... };

Une autre solution consiste à utiliser la classe reference_wrapper (dans l’en-tête fonctionnel): 

 struct A { A(int& a) : a_(a) {} A(const A& a) : a_(a.a_) {} A& operator=(const A& a) { a_ = a.a_; return *this; } void inc() const { ++a_; } std::reference_wrappera_; };

Ce que vous faites est techniquement correct pour autant que je sache, mais cela crée des problèmes. Par exemple, considérons ce qui se passe avec une classe dérivée de A , puisque son opérateur d’affectation génère un nouvel object (découpage). Ne pouvez-vous pas simplement transformer la référence en pointeur dans votre classe?

De plus, les constructeurs de copie et les opérateurs d’assignation prennent généralement leur argument de const& .

Ce que vous faites est correct, mais ce n’est pas un moyen très sûr d’écrire un opérateur d’atsortingbution de copie. En outre, vous devriez envisager d’utiliser un membre de pointeur plutôt qu’un membre de référence.

Vous devez l’implémenter en utilisant les expressions Copier et Swap Il présente au moins 3 avantages par rapport à votre implémentation.