Vérifier la valeur null dans une std::shared_ptr

Je me demandais si j'ai besoin de vérifier si sp est null avant que je l'utilise.
Corrigez-moi si je me trompe, mais la création d'un alias ne sera pas augmenter la ref compteur et, par conséquent, en entrant dans la méthode que nous travaillons avec un pointeur partagé que nous ne savons pas si le pointeur intégré a été mis à zéro avant.. suis-je corriger en tenant compte de cet?

Class::MyFunction(std::shared_ptr<foo> &sp)
{    
    ...  
    sp->do_something();  
    ...  
}

Seulement si il peut utiliser C++11. Pas tout le monde est un amateur de programmeur avec un contrôle sur son de la chaîne.
En effet (et, je le concède, une carrière dans un hedge fund est un passe-temps), mais le développement de l'efficacité personnelle compétences pour déplacer votre entreprise vers l'avant est important.
Je suis d'accord: au moins l'écrire dans votre propre temps, oui!

InformationsquelleAutor Nostradamus | 2014-03-06

c++shared-ptr

16

Plus partagés les pointeurs sont exactement comme les pointeurs dans ce
le respect. Vous avez pour vérifier la valeur null. En fonction de la
fonction, vous pouvez passer à l'utilisation de
```
void myFunction( Foo const& foo );
```
et en l'appelant par un déréférencement du pointeur (qui pousse le
la responsabilité de veiller à ce que le pointeur n'est pas null à la
l'appelant).

Aussi, c'est probablement une mauvaise pratique de faire de la prise de fonction
un pointeur partagé sauf il y a quelques spécial de la propriété
la sémantique impliqués. Si la fonction va seulement utiliser l'
pointeur pour la durée de la fonction, ni de le changer ou d'
de la prise de possession, un pointeur brut est probablement plus approprié,
puisqu'elle impose moins de contraintes sur l'appelant. (Mais ce
dépend vraiment de beaucoup de choses sur ce que la fonction n', et pourquoi vous
l'utilisation partagée des pointeurs. Et bien sûr, le fait que vous avez
passé un non-const de référence pour le pointeur partagé suppose que
vous allez le modifier, de sorte que le passage d'un pointeur partagé peut être
approprié.)

Enfin, différentes implémentations de partage des pointeurs de le faire
plus ou moins difficile à vérifier la valeur null. Avec C++11, vous pouvez
utilisation std::shared_ptr, et il suffit de comparer à nullptr
naturellement, comme vous le souhaitez. Le coup de pouce de la mise en œuvre est un peu
rompu à cet égard, toutefois, vous ne peut tout simplement pas comparer à
0 ou NULL. Vous devez construire un vide
boost::shared_ptr pour la comparaison, ou appelez get sur elle et
comparer le résultant pointeur brut à 0 ou NULL.

InformationsquelleAutor James Kanze
45

Vous avez à considérer que std::shared_ptr est globalement toujours un pointeur (encapsulé dans un pointeur comme la classe) et qu'il peut en effet être construit à l'interne nullptr. Lorsque cela se produit, les expressions comme:
```
ptr->
*ptr
```
conduit à un comportement indéfini. Donc, oui, si vous vous attendez à le pointeur également être nullptr, alors vous devriez vérifier sa valeur avec:
```
ptr != nullptr
```
ou
```
!ptr
```
(grâce à son opérateur booléen).
- ... ou tout simplement !ptr
- Sauf que !ptr est à éviter, sauf si votre but est de l'obscurcissement. Il est présent à émuler les premières pointeurs, mais c'est un misfeature de raw pointeurs, hérité de C, et doit être évitée dans le code écrit (même en C).
- C et C++ de travail en partie sur l'hypothèse que 0 == false, c'est partout et vous ne pouvez pas l'éviter, beaucoup moins en éloigner. Cette association est gravé dans mon programmeur cerveau, même si je n'ai pas touché C dans un temps long, et je pense que beaucoup d'autres programmeurs C++ sentir de cette façon, aussi.
InformationsquelleAutor Shoe
3

Il n'y a pas de point dans le passage d'un shared_ptr comme référence.

Vous pouvez obtenir à l'intérieur de l'objet via boost::shared_ptr<T>.get() et vérifier nullptr

Aussi pertinent: se déplacer à std 🙂

Modifier: C'est la mise en œuvre: http://www.boost.org/doc/libs/1_55_0/boost/smart_ptr/shared_ptr.hpp
Et voici un thread à propos de ref ou pas de ref: Dois-je passer un shared_ptr par référence?

Il utilise la sémantique de déplacement lorsque Cx11 et des copies de deux ints autre, qui est plus lent que de passer une référence, mais quand est-ce que quelqu'un sur ce niveau d'optimisation?
- Que voulez-vous dire il n'y a pas de point? Nous savons peu de choses sur ce que la fonction n'. Et vous n'avez pas besoin get() pour vérifier la valeur null.
- L'ensemble de la conception d'un pointeur intelligent est le concept d'être rapide pour être copié. Dans Cx11 il utilise la sémantique de déplacement, et avant cela il essentiellement des copies de deux entiers, comme indiqué dans le shared_ptr mise en œuvre. Cela devrait vraiment pas être un impact sur les performances. Testant la valeur null devrait être possible sans .get() vous avez raison.
- "Il n'y a pas de point dans le passage d'un shared_ptr comme référence." - [citation nécessaire]. Vous pouvez passer par la const de référence (c'est à dire "rendre clair l'API d'un module n'affecte pas la valeur"), ou par référence (c'est à dire "considérer comme une variable de sortie"). En passant par (const) de référence peuvent être mandatés par des conventions de codage des raisons techniques ("modèle de spécialisation reçoit en argument const de référence") et ainsi de suite.
- cette question a été posée avant: stackoverflow.com/questions/8385457/...
- Avec boost::shared_ptr, vous avez besoin soit get, ou vous avez besoin de construire un vide boost::shared_ptr juste pour la comparaison, ou vous avez besoin d'utiliser l'obscurcissement de la conversion implicite. À l'aide de get est probablement la meilleure (ou la moins mauvaise) solution.
- Le haut voté réponse dans la cité fil est complètement faux. Tout d'abord, la question ici (et là) implique une non-const de référence. Si c'est vraiment ce qui est voulu, cela signifie que la fonction appelée peut modifier l'argument, ce qui nécessite une référence. Sinon, le pointeur est un type défini par l'utilisateur, de sorte que la règle habituelle est de le passer par référence const, et de ne pas avoir de valeur.
- Copier (ne bouge pas) un shared_ptr implique une atomique incrémentation d'un compteur. Les opérations atomiques ne sont jamais "libre".
- Samuel est correct, l'auteur ne doit pas passer la shared_ptr par référence. Le "moderne" de la convention est de passer par valeur à moins que vous appelez reset()
InformationsquelleAutor Samuel
2

Il n'y a pas de réponse générale à cette question. Vous devez les traiter comme n'importe quel autre pointeur. Si vous ne savez pas si c'est null, test. Si vous croyez qu'il sera jamais nulle, assert() que ce n'est pas null et de l'utiliser directement.

Le fait que vous avez une référence à shared_ptr, ou même que vous avez un shared_ptr, n'a pas d'impact ici.

InformationsquelleAutor Angew

Vous devez vous connecter pour publier un commentaire.