Pointeur NULL avec boost :: shared_ptr?

Votre suggestion (appeler le constructeur shared_ptr sans argument) est correcte. (L’appel du constructeur avec la valeur 0 est équivalent.) Je ne pense pas que cela serait plus lent que d’appeler vec.push_back() avec un shared_ptr préexistant, puisque la construction est requirejse dans les deux cas (soit directe construction ou copie-construction).

Mais si vous voulez une syntaxe “plus agréable”, vous pouvez essayer le code suivant:

 class { public: template operator shared_ptr() { return shared_ptr(); } } nullPtr; 

Cela déclare un object global unique nullPtr , qui active la syntaxe naturelle suivante:

 shared_ptr pi(new int(42)); shared_ptr psat(new SomeArbitraryType("foonly")); ... pi = nullPtr; psat = nullPtr; 

Notez que si vous l’utilisez dans plusieurs unités de traduction (fichiers source), vous devrez donner un nom à la classe (par exemple, _shared_null_ptr_type ), déplacer la définition de l’object nullPtr dans un fichier .cpp distinct et append des déclarations extern dans le fichier. fichier d’en-tête où la classe est définie.

Eh bien, c’est légal:

 shared_ptr foo; /* don't assign */ 

Et dans cet état, il ne pointe rien. Vous pouvez même tester cette propriété:

 if (foo) { // it points to something } else { // no it doesn't } 

Alors pourquoi ne pas faire ça:

 std::vector < shared_ptr > vec; vec.push_back (shared_ptr); // push an unassigned one 

En C ++ 0x, vous pouvez simplement convertir de nullptr en std::shared_ptr :

 std::vector< boost::shared_ptr > vec; vec.push_back(nullptr); 

Vous pouvez déclarer un nullPtr global pour shared_ptr . Mais si vous polluez l’espace de noms global, comment nullPtr vous le nullPtr global pour shared_ptr ?

En général, je déclare le null ptr en tant que statique dans la classe du pointeur.

 #include  class Foo; // forward decl typedef boost::shared_ptr FooPtr; class Foo { public: static FooPtr Null; } ... // define static in cpp file FooPtr Foo::Null; ... // use Foo Null vec.push_back(Foo::Null); 

De cette façon, chaque classe a un Null statique.

Voici quelque chose que je trouve un peu plus simple et qui fonctionne très bien

(rappelez-vous que typedef est votre ami):

 #include  #include  #include  #include  typedef boost::shared_ptr< std::vector > CharVecHandle; inline CharVecHandle newCharVec(std::vector::size_type size) { return CharVecHandle(new std::vector(size)); } inline CharVecHandle newCharVec(void) { return CharVecHandle(); } int main ( void ) { CharVecHandle cvh = newCharVec(); if (cvh == NULL) std::cout << "It's NULL" << std::endl; else std::cout << "It's not NULL" << std::endl; std::vector< CharVecHandle > cvh_vec; cvh_vec.push_back(newCharVec(64)); cvh_vec.push_back(newCharVec()); // or call the NULL constructor directly cvh_vec.push_back(CharVecHandle()); return EXIT_SUCCESS; } 

Oui, déclarez un pointeur null statique global.