C.60: Copiez le Make INCESSIBILITÉ virtuel, par const & Take paramètre, et retour par des non-const &
C.60: copies de l' opérateur d'affectation const & doivent être basées sur les paramètres, le type de retour de la fonction virtuelle référence non const
Raison (raison)
Il est simple et efficace. Si vous souhaitez optimiser pour rvalues, fournir une surcharge qui prend un && (voir F.18).
Pour cette raison simple et efficace. Si vous souhaitez optimiser la valeur du droit de fournir une utilisation && (références rvalue) surcharge.
Exemple (Exemple)
class Foo {
public:
Foo& operator=(const Foo& x)
{
// GOOD: no need to check for self-assignment (other than performance)
auto tmp = x;
swap(tmp); // see C.83
return *this;
}
// ...
};
Foo a;
Foo b;
Foo f();
a = b; // assign lvalue: copy
a = f(); // assign rvalue: potentially move
Note (Note)
La technique de mise en œuvre de swap offre la garantie forte.
fonction de permutation à la technologie (voir C.83) est fourni (copie ne se produit pas depuis, note du traducteur) forte garantie.
Exemple (Exemple)
Mais si vous pouvez obtenir des performances nettement meilleures en ne faisant pas une copie temporaire? Considérons simple vecteur destiné à un domaine où l'affectation de grands vecteurs de taille égale est commune. Dans ce cas, la copie des éléments sous-entendus par la technique de mise en œuvre d'échange pourrait provoquer une augmentation de l'ordre de grandeur du coût:
Mais vous ne pouvez pas passer au moins une fois une copie temporaire de l'action soit une performance nettement supérieure? Considéré comme (éléments, Ndt) simple scène de la même taille Vector d'affectation vecteur énorme. Dans ce cas, les éléments techniques réalisés en copiant l'opération d'échange entraînera une augmentation substantielle du coût.
Note du traducteur
L'exemple précédent, un constructeur de copie effectuée avant échange
template<typename T>
class Vector {
public:
Vector& operator=(const Vector&);
// ...
private:
T* elem;
int sz;
};
Vector& Vector::operator=(const Vector& a)
{
if (a.sz > sz) {
// ... use the swap technique, it can't be bettered ...
return *this;
}
// ... copy sz elements from *a.elem to elem ...
if (a.sz < sz) {
// ... destroy the surplus elements in *this and adjust size ...
}
return *this;En écrivant directement aux éléments cibles, nous aurons la garantie de base plutôt que la forte garantie offerte par la technique d'échange. Méfiez-vous des auto-affectation.
Les données sont écrites directement par l'élément d'objet, nous pouvons obtenir une sécurité de base, pas forte garantie fournie par la technologie d'échange. Afin de nous éviter la cession.
Alternatives (facultatif)
Si vous pensez que vous avez besoin d'un opérateur d'affectation virtuel, et comprendre pourquoi c'est très problématique, ne l'appelez pas l'opérateur =. Faites-en une fonction nommée comme assign virtual void (const Foo &). Voir clone par rapport constructeur de copie ().
Si vous pensez que vous avez besoin d'un opérateur d'affectation virtuelle, et il produira une compréhension profonde du problème, ne pas conçu comme un opérateur d'affectation. Il est défini comme une fonction appelée, par exemple assign vide virtuel (const Foo &). [Référence] Clonage vs constructeur de copie.
Le clonage d'un constructeur de copie vs lien:
https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Rc-copy-virtual
Application (Suggestions)
-
(Simple) Un opérateur d'affectation ne doit pas être virtuelle. Voilà des dragons!
(Simple) opérateur d'affectation ne doit pas être virtuelle. Faites très dangereux.
-
(Simple) Un opérateur d'affectation doit retourner T & pour permettre chaîner, pas des alternatives comme const T & qui interfèrent avec composabilité et de placer des objets dans des conteneurs.
opérateur affectation (simple) devrait revenir à T &, de manière à atteindre l'affectation continue. Ne pas modifier le type const T & De même, il aura une incidence et interférer avec l'ensemble des objets dans le conteneur.
-
(Modéré) Un opérateur d'affectation doit (implicitement ou explicitement) tous les opérateurs Invoke d'affectation base et membres. Regardez le destructor pour déterminer si le type a la sémantique de pointeur ou la sémantique de valeur.
opérateur d'affectation (moyenne) devrait (implicitement ou explicitement) appelle la classe de base et tous les membres de l'opérateur d'affectation. Destructeur a été observée pour déterminer le type de la sémantique de pointeur de la sémantique de la formule ou la valeur.
lien Description
https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c60-make-copy-assignment-non-virtual-take-the-parameter-by-const-and-return-by-non- const
Je pense que cet article utile? Bienvenue pouces et partager avec plus de gens.
Lire la suite des articles mis à jour, s'il vous plaît attention à numéro public micro-canal de la pensée orientée objet []
