Pourquoi a-t-on besoin d'un nul shared_ptr et comment peut-il être utilisé?

De Scott Meyers Effective C++, l'article 18 Faire des interfaces faciles à utiliser correctement et difficile à utiliser de manière incorrecte, il a mentionné l'null shared_ptr:

std::tr1::shared_ptr<Investment> pInv(static_cast<Investment*>(0), getRidOfInvestment)

et la vogue de cette opération, le

pInv = ...     //make retVal point to the correct object

Auquel cas on peut avoir besoin de créer une valeur null shared_ptr et ne travail plus tard? Pourquoi ne pas simplement créer le shared_ptr chaque fois que vous avez les ressources (pointeur brut)?

Depuis Scott Meyers n'a pas montré le complète d'affectation dans l'exemple précédent, je pensais que le shared_ptr d'assignation de l'opérateur est surchargé que l'on peut faire ceci:

pInv = new Investment;    //pInv will take charge of the pointer
                          //but meanwhile keep the delete function it already had

Mais j'ai essayé avec boostmise en œuvre, il ne fonctionne pas de cette façon. Alors quel est le sens d'avoir la valeur null shared_ptr?

Je suis presque sûr que je suis absent quelque chose ici, quelqu'un m'aider s'il vous plaît.

ps. plus sur l'initialisation et affectation d'un shared_ptr

#include <boost/shared_ptr.hpp>

int main(int argc, char *argv[])
{
    boost::shared_ptr<int> ptr1(new int);
    boost::shared_ptr<int> ptr2;
    ptr2.reset(new int);
    boost::shared_ptr<int> ptr3 = new int;

    return 0;
}

cet exemple ne peut pas être compilé par g++ (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2 et le dernier boost:

sptr.cpp: In function ‘int main(int, char**)’:
sptr.cpp:8:39: error: conversion from ‘int*’ to non-scalar type ‘boost::shared_ptr<int>’    requested

J'ai essayé de le comprendre, ici: ideone.com/BUjOwZ. Je n'arrivais pas à trouver une explication.
Comme d'autres l'ont souligné, il ya beaucoup de raisons d'avoir besoin d'un nul shared_ptr, tout comme vous avez null raw pointeurs. Mais le vrai mystère est pourquoi Scott ressenti le besoin de disposer d'une coutume deleter.

OriginalL'auteur zhanwu | 2011-07-28

c++c++11 effective-c++shared-ptr

19

Il n'est pas nécessaire pour utiliser ce hack pour obtenir une valeur null (vide) shared_ptr. Simplement utiliser le constructeur par défaut:
```
std::shared_ptr<Investment> pInv; //starts null
```
Pour affecter un pointeur vers une shared_ptr, soit le faire au moment de la construction:
```
std::shared_ptr<Investment> pInt(new Investment);
//not allowed due to explicit annotation on constructor:
//std::shared_ptr<Investment> pInt = new Investment;
```
Ou utiliser le .reset() fonction:
```
pInt.reset(new Investment);
```
Il est possible que l'auteur de cet article peut-être l'intention de fournir une coutume deleter (getRidOfInvestment). Cependant, la deleter fonction est remise à zéro lorsque .reset() est appelé, ou autrement l'intérieur pointeur est modifié. Si vous voulez une coutume deleter, vous devez passer à .reset() lors de la création de la shared_ptr.

Un modèle que vous pourriez utiliser pour faire de ce plus à toute épreuve est une création personnalisée de la fonction:
```
class Investment {
protected:
  Investment();
  //...
public:
  static shared_ptr<Investment> create();
};

shared_ptr<Investment> Investment::create() {
  return shared_ptr<Investment>(new Investment, getRidOfInvestment);
}
```
Plus tard:
```
shared_ptr<Investment> pInv = Investment::create();
```
Cela garantit que vous aurez toujours le bon destructeur de la fonction attachée à l' shared_ptrs créés à partir de Investments.

L'exemple givien dans la quetion, la raison pour laquelle le pointeur null dans le constructeur d'appel est l'utilisation d'une coutume deleter. Le constructeur de la smart pointeur de ne pas avoir une version qui ne prend que la coutume deleter, d'où la nécessité pour le "hack".
Bon point, j'ai ajouté un peu pour discuter.
"std::shared_ptr<Placement> pinte = de nouveaux Investissements;" ne peut pas être compilé
de toute façon, parce que lorsque vous réinitialisez le pointeur de la coutume deleter sera également réinitialiser, droit? puis le nul shared_ptr avec une coutume deleter complètement aucun sens réel de la programmation, tellement bizarre d'avoir un tel exemple dans ce joli livre
Je suppose qu'il me manquait quelque chose, j'ai refusé de croire que Scott peut se tromper! Mais c'est la seule explication que je peux trouver, +1

OriginalL'auteur bdonlan

C'est la même raison pour avoir une valeur null pointeur brut - par exemple

dire que vous avez:

typedef std::tr1::shared_ptr<Investment> InvestmentPtr;
map<key,InvestmentPtr> portfolio;
...
get(mykey) {
  iterator it = portfolio.find(mykey);
  if (it == portfolio.end()) 
    return InvestmentPtr();
  else 
    return it->second;
  }
}

Cela vous permet de faire:

InvestmentPtr p = get(key);
if (p) ...

OriginalL'auteur naumcho

2

Il y a des tonnes de raisons pour lesquelles vous pourriez, comme des objets à la valeur par défaut constructible. D'abord et avant tout, vous voulez que le pointeur intelligent pour être aussi semblables que possible à un pointeur brut, et puisque vous pouvez dire int * p; (et obtenir un indéfini, pointeur non initialisé), vous pouvez aussi dire shared_ptr<int> p; et obtenir un pointeur qui ne pointe pas n'importe où (mais vous arrivez à le tester avec !).

L'une des raisons les plus convaincantes est peut-être que vous pouvez faire de conteneurs avec shared_ptrs, et vous pouvez remplir les récipients sans affecter pointees à droite et puis.

OriginalL'auteur Kerrek SB

Vous devez vous connecter pour publier un commentaire.