Explication de l'extrait de code ci-dessous C ++

Je lisais Faq C ++ 11 et suis tombé sur ce code. J'ai une meilleure compréhension du codage C ++, mais je ne suis toujours pas capable de comprendre le code ci-dessous.

    template
    class Handle {
        T* p;
    public:
        Handle(T* pp) : p{pp} {}
        ~Handle() { delete p; }//user-defined destructor: no implicit copy or move 

        Handle(Handle&& h) :p{h.p} { h.p=nullptr; };   //transfer ownership
        Handle& operator=(Handle&& h) { delete p; p=h.p; h.p=nullptr; return *this; }  //transfer ownership

        Handle(const Handle&) = delete;    //no copy
        Handle& operator=(const Handle&) = delete;

       //...
    };
  • Que signifie "transférer la propriété"?
  • Pourquoi la copie ctor est-elle assimilée à " delete "? comment est-ce utile?

S'il vous plaît si quelqu'un peut ajouter quelques exemples avec des explications, ce serait une aide précieuse.

1
ajouté l'auteur Mike Seymour, source
ajouté l'auteur Raxvan, source
ce n'est pas une copie ctor c'est un mouvement ctor.
ajouté l'auteur PeterT, source

3 Réponses

It's a move constructor, the special && syntax introduced in C++11 takes a rvalue reference, so a reference to a variable which has no name and can't be referenced anywhere else inside the code.

Qu'est-ce qui se passe dans le constructeur est que le Handle prend la propriété du Handle passé par le constructeur de déplacement de la façon dont vole (laissez-moi passer le terme) le T * p à l'intérieur en affectant sa valeur à sa propre variable, puis en définissant nullptr à la variable de la valeur passée.

Ceci est utilisé parce que vous n'avez pas vraiment besoin de copier un rvalue, puisque cette valeur ne sera plus utilisée dans le code, donc il est sûr de prendre ses données, ceci évite un constructeur de copie, éventuellement coûteux.

1
ajouté

En C ++ vous aviez des constructeurs de copie et des opérateurs de copie, qui étaient chers si votre objet était grand. Maintenant, en C ++ 11, vous avez un constructeur de déplacement et un opérateur de déplacement qui dit "prenez tout de la source et tuez-le".

mybigthing y ;
...
mybigthing x( move(y)) ;

y est créé avec beaucoup de choses en interne. après x (y), y est maintenant vide et toutes les grandes choses sont dans x.

Une des raisons principales est de rendre le retour de gros objets à partir de fonctions libres:

mybigthing f()
{
  mybigthing tmp ;
  ...
  return tmp ;
}

{
  mybigthing y= f() ;
}

En c ++ 03, ce serait une performance horrible. Maintenant c'est gratuit. Les compilateurs doivent réellement utiliser y en tant que temporaire à l'intérieur de f() et ne jamais faire de copies.

0
ajouté

à propos de votre deuxième question: Pourquoi la copie ctor est-elle assimilée à "supprimer"? comment est-ce utile?

Here is an answer: http://www.developerfusion.com/article/133063/constructors-in-c11/

C ++ 11 Constructeurs explicitement supprimés

     

C ++ 11 supporte également le concept de constructeurs explicitement supprimés.   Par exemple, vous pouvez définir une classe pour laquelle vous ne voulez pas écrire   tous les constructeurs et vous ne voulez pas que le compilateur génère le   constructeur par défaut. Dans ce cas, vous devez supprimer explicitement le   constructeur par défaut:

     

class MyClass {public:       MyClass() = supprimer; };

0
ajouté
Merci !! c'est utile et informatif
ajouté l'auteur user2598064, source