shared_ptr null pointeur et affectation

Je veux utiliser shared_ptr, tout comme j’utiliserais un pointeur réel. Je voulais être capable de faire des choses comme

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

mais ce n’est pas implémenté par défaut.

J’ai changé le code source du shared_ptr de la librairie boost en ajoutant

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

La seule chose est que si je fais un = -1; cela va comstackr et me donner un pointeur null, ce qui ne devrait pas poser de problème car normalement vous ne pouvez pas affecter une valeur entière à un pointeur.

Ma question est donc la suivante: s’agit-il d’une manière correcte d’implémenter ceci ou ai-je oublié des cas qui pourraient bloquer l’application? Parce que partout où j’ai regardé, la seule façon d’obtenir un nullpointer pour un shared_ptr était d’appeler le constructeur par défaut qui n’est pas très élégant en code par rapport à: ptr = 0 ;.

Non, ne changez pas la source. C’est comme ça pour une raison et des personnes très intelligentes ont décidé que la façon dont elle est définie est meilleure que ce que vous allez modifier.

Ce que vous avez n’a même pas de sens. Vous ne pouvez pas assigner un entier à un pointeur, ce sont deux types différents, mais vous lui avez donné une telle sémantique. Vous dites: “… ce qui ne devrait pas poser de problème, car normalement, vous ne pouvez pas atsortingbuer une valeur entière à un pointeur”, mais vous avez également indiqué en haut de votre question “Je souhaite utiliser shared_ptr comme je le ferais auparavant.” utiliser un pointeur réel “. Bien, c’est quoi? Parce qu’atsortingbuer des entiers à des pointeurs pour les définir sur NULL est à peu près aussi loin d’un pointeur réel que vous pouvez obtenir.

Vous devez prendre du recul et réaliser que ce que vous voulez n’est pas toujours la meilleure chose à faire. Vous devez annuler ces modifications et utiliser la classe correctement. Je ne veux pas être méchant, mais ce n’est vraiment pas la voie à suivre; c’est dangereux, sa sémantique est absurde et il est tout à fait impossible à maintenir.

shared_ptr implémente une interface de type pointeur afin que vous puissiez utiliser l’opérateur * et -> .

Shared_ptr construit par défaut (vide) sera égal à nullptr en interne, vous n’avez donc pas à vous soucier de l’affecter explicitement. c’est à dire

 std::shared_ptr sh; std::cout << ( sh.get() == nullptr ) << std::endl; // Or alternatively: std::cout << ( sh == nullptr ) << std::endl;

De plus, à mon avis, la fonction std::make_shared est la façon la plus élégante d’utiliser shared_ptr pour créer des objects. Cela a aussi l'avantage d'être légèrement plus efficace dans certains compilateurs (du moins sur MSVC ++) en raison d'une optimisation interne appelée "nous soaps où vous vivez".

 #include  #include  class foo { public: foo(std::ssortingng s, int n) {} }; int main() { auto p = std::make_shared(); auto q = std::make_shared("hello", 2); }