shared_ptr pointeur null et affectation

Je veux utiliser shared_ptr comme j'utilise un réel pointeur. Je voulais être capable de faire des choses comme

shared_ptr<int> a;
a = new int(5);
a = 0;
shared_ptr<int> foo()
    return 0;

mais il n'est pas implémentée par défaut.

J'ai changé le code source de la shared_ptr de la bibliothèque boost en ajoutant

template<class Y> void operator=( int i )
{
    reset(i);
}
template<class Y> void reset(int i)
{
    this_type(i).swap(*this);
}
template<class Y> void operator=( Y * p )
{
    reset(p);
}
shared_ptr(int i): px(0), pn()
{
}

La seule chose est que si je fais un = -1; compiler et de me donner un pointeur null, ce qui ne devrait pas être un problème parce que, normalement, vous ne pouvez pas affecter un entier à un pointeur.

Donc ma question est, est-ce une bonne façon de mettre en œuvre cette ou ai-je oublié des cas qui pourraient bloquer l'application? Parce que partout où je regardais, la seule façon que je voyais pour obtenir un nullpointer pour un shared_ptr a été d'appeler le constructeur par défaut qui n'est pas très élégant dans le code par rapport à: ptr = 0;.

Un littéral 0 est un null le pointeur constant est donc implicitement convertible en un valeur de pointeur null de tout type pointeur déjà.
+1 ", j'ai changé le code source de la shared_ptr de la bibliothèque boost" 😉
pourquoi ne pas utiliser le C++11 nullptr à la place?

OriginalL'auteur Michael Ferris | 2012-04-22

c++null pointers shared-ptr

25

Pas. De ne pas modifier la source. C'est comme ça pour une raison et les gens très intelligents ont décidé que la façon dont il est défini n'est mieux que tout ce que vous allez modifier.

Ce que vous avez n'a même pas de sens. Vous ne pouvez pas affecter un entier à un pointeur, ils sont de deux types différents, mais vous avez donné l'exemple de la sémantique. Vous dites: "...ce qui ne devrait pas être un problème parce que, normalement, vous ne pouvez pas affecter un entier à un pointeur", mais vous avez dit au début de votre question "je veux utiliser shared_ptr comme j'utilise un réel pointeur". Eh bien, qui est-il? Car l'attribution des entiers pointeurs pour les mettre à null est à peu près aussi loin d'une réelle pointeur que vous pouvez obtenir.

Vous avez besoin de prendre du recul et de réaliser ce que vous voulez n'est pas toujours la meilleure chose à faire. Vous devriez revenir à ces changements et d'utiliser la classe correctement. Je ne veux pas être méchant mais c'est sérieux pas l'itinéraire que vous voulez aller; c'est dangereux, n'a pas de sens sémantique, et est tout autour de difficile à maintenir.

Oui, vous avez raison. Je suppose que j'étais tout simplement paresseux parce que je ne veux pas tout changer parce que j'avais une forme normale avant et était en train de changer de puce ptr. Je me doutais de ce que je faisais était mal, et c'est pourquoi j'ai demandé 🙂
C'est bien, mais parfois vous avez juste à se mettre au travail, en particulier lors d'un refactoring de code. 🙂 Comme votre style de codage s'améliore, vous trouverez qu'il est préférable d'être explicite sur les choses. Tout implicite de fonctionnalités signifie moins de travail pour vous, cela signifie généralement moins de clarté et de sécurité pour vous. Simplement en regardant return 0;, par exemple, vous pourriez penser que vous êtes de retour le zéro, pas un pointeur null. Mais il n'y a pas de confusion quand vous dites return boost::shared_ptr<int>();. En fait, c'est tellement vrai que la nouvelle norme C++ introduit un nouveau mot-clé juste valeur null: nullptr.
Je ne connaissais même pas l'existence de nullptr. Merci! 🙂 Aussi, j'ai choisi d'utiliser le shared_ptr dans la lib standard, donc je ne pas avoir à transporter une grande bibliothèque comme boost. Encore beaucoup de choses à apprendre 😉
Si vous pouvez l'utiliser, certainement obtenir dans l'habitude. Tous les compilateurs maintenant de le soutenir, et il nous est très utile. Aussi, bienvenue sur StackOverflow.

OriginalL'auteur GManNickG
9

shared_ptr met en œuvre un pointeur-comme l'interface de sorte que vous pouvez utiliser le * et -> opérateur.

Un défaut-construit (vide) shared_ptr sera égal à nullptr en interne, de sorte que vous n'avez pas besoin de s'inquiéter au sujet de l'attribution explicitement. c'est à dire
```
std::shared_ptr<int> sh;
std::cout << ( sh.get() == nullptr ) << std::endl;

//Or alternatively:
std::cout << ( sh == nullptr ) << std::endl;
```
Aussi, (à mon avis) de la façon la plus élégante d'utiliser shared_ptr pour créer des objets est la std::make_shared fonction. Cela a aussi l'avantage d'être légèrement plus efficace dans certains compilateurs (au moins sur MSVC++) en raison de certains internes d'optimisation connu comme le "nous savons où vous habitez idiome"
```
#include <memory>
#include <string>

class foo
{
public:
    foo(std::string s, int n) {}
};

int main()
{
    auto p = std::make_shared<int>();
    auto q = std::make_shared<foo>("hello", 2);
}
```
OriginalL'auteur Ben Cottrell

Vous devez vous connecter pour publier un commentaire.