Comment empêcher la suppression de pointeurs gérés par un QSharedPointer

Question

J'ai quelques erreurs de segmentation intermittentes dans une application Qt. Je pense que le problème est lié à notre (mauvaise) utilisation de QSharedPointer. Qt Etats Documentation :

  

QSharedPointer :: QSharedPointer (T * ptr):   Crée un QSharedPointer que les points à ptr. Le pointeur ptr devient géré par ce QSharedPointer et ne doit pas être transmis à un autre objet QSharedPointer ou supprimé en dehors de cet objet .

Je pense que nous faisons à la fois ne doit pas ...: /

Y at-il un moyen de faire respecter POO que le pointeur géré par QSharedPointer ne peut être supprimé ou transmis à un autre QSharedPointer?

La meilleure solution sera d'avoir une erreur de compilation.

Answer 1

Le modèle normal est de mettre l'instruction new à l'intérieur du constructeur du pointeur intelligent, comme ceci:

QSharedPointer<Obj> p (new Obj(2)); 

De cette façon, vous n'avez une référence au pointeur nu lui-même.

Si vous Refactor votre code afin que tout nouvel opérateur sont en lignes comme celles-ci, tous vos problèmes seront résolus.

Answer 2

Eh bien, d'une manière POO-esque serait de créer le pointeur brut en tant que membre privé dans une classe wrapper et effectuer uniquement des actions sur le pointeur par des méthodes qui agissent sur le pointeur partagé. sorte de bien stupide, non?

Ou vous pourriez faire votre classe avec le pointeur brut d'une classe de base à vos autres classes et faire le pointeur brut un membre privé dans la classe. À cet égard, vous êtes plus ou moins la création d'une classe abstraite qui ne fait rien. Vos cours dérivés doivent plutôt faire tout le travail, et qu'ils ne peuvent pas accéder au pointeur brut, la compilation échouera ... cela ne quelqu'un pas arrêter de copier seulement la valeur de pointeur brut sur le pointeur partagé, cependant.

En fin de compte, je pense que votre meilleure politique est de manuall changer toutes les fonctions en question à utiliser un pointeur partagé ou bien un pointeur brut. Vous pouvez copier un pointeur partagé à un autre en toute sécurité, alors pourquoi pas tout simplement aller dans ce sens?

Edit: Je pourrais ajouter que peu importe si oui ou non vous utilisez des pointeurs partagés, il semble que vous avez des problèmes de propriété. Si un pointeur a été créé dans un champ, il convient de supprimer dans ce champ, à moins que la fonction qu'elle est passée à contrat prend possession du pointeur. L'utilisation d'un pointeur partagé dans ce scénario ne fait différents bugs, par la suite. Il semble que vous avez des problèmes de conception plus profond que le simple partage des pointeurs.

Answer 3

Je ne suis pas au courant de la mise en œuvre Qt particulier d'un pointeur partagé, mais comme une ligne directrice générale: essayer de mélanger des pointeurs premières avec des pointeurs gérés se termine généralement dans le sang. Une fois que vous « confiance » une mise en œuvre du pointeur partagé dans l'appropriation de vos données dynamiquement allouées, vous ne devez en aucun cas essayer de gérer la durée de vie de l'objet vous-même (par exemple en supprimant le pointeur fourni).

Est-il possible de faire respecter POO que le pointeur géré par QSharedPointer ne peut pas être supprimé?

Je suppose que vous pourriez imaginer une technique bizarre où le type pointu aurait un destructor privé et déclarer QSharedPointer comme ami (qui empêcherait efficacement toute « suppression en dehors » de la compilation), mais je ne parierais pas que bon rien ne peut venir de ce (et notez qu'il fera votre type tout à fait inutilisable à moins new'ed et transféré à un QSharedPointer).

Est-il possible de faire respecter POO que le pointeur géré par QSharedPointer ne peut pas être passé à un autre QSharedPointer?

Je ne peux pas penser à tout, et qui est une autre raison pour laquelle vous devriez éviter de manipuler le pointeur brut une fois qu'il est la propriété a été transférée à un QSharedPointer.

Answer 4

Vérifiez votre code pour toute utilisation .data () et assurez-vous ce qu'ils reviennent est ni stockées, ni supprimé. Je ne pense pas une erreur matérielle du compilateur serait bon, parce que parfois il est normal de passer le pointeur brut, par exemple à une fonction qui ne stocke pas, ni supprimer des pointeurs transmis. (En particulier lors de l'utilisation du code 3ème partie, vous ne pouvez pas toujours tout changer d'utiliser des pointeurs partagés, et souvent vous voulez que cela fonctionne avec les deux, les REE premières et partagées). On pourrait marquer QSharedPointer :: données () comme dépréciée (par rapiéçage Qt), pour obtenir un avertissement de compilation.