Supprimer explicitement un shared_ptr

Simple question: êtes-vous autorisé explicitement supprimer un boost::shared_ptr vous-même? Si jamais vous?

Clarifier, je ne veux pas supprimer le pointeur détenus par le shared_ptr. Je voulais dire le réel shared_ptr lui-même. Je sais que la plupart des gens suggèrent de ne pas le faire, donc je me demandais juste si c'est OK explicitement de le faire.

source d'informationauteur garsh0p

  1. 24

    Votre question n'est pas claire. Si vous avez alloué un shared_ptr dynamiquement, alors vous êtes certainement permis à delete quand vous le souhaitez.

    Mais si vous vous demandez si vous êtes autorisé à supprimer un objet géré par le shared_ptralors la réponse est ... ça dépend. Si shared_ptr::unique retourne true, alors l'appel de shared_ptr::reset permet de supprimer l'objet géré. Toutefois, si shared_ptr::unique renvoie la valeur false, cela signifie qu'il existe plus d'une shared_ptrs le partage de la propriété de cet objet. Dans ce cas, un appel à reset aura seulement le nombre de références d'être décrémenté de 1, la suppression effective de l'objet n'aura lieu que lorsque la dernière shared_ptr la gestion que l'objet est hors de portée ou est lui-même reset.

    EDIT:

    Après votre montage, il semble que vous posez des questions à propos de la suppression d'un allouée dynamiquement shared_ptr. Quelque chose comme ceci:

    auto sp = new boost::shared_ptr<int>( new int(42) );

//do something with sp

delete sp;

    Ce qui est permis et fonctionnera comme prévu, bien qu'il soit inhabituel de cas d'utilisation. Le seul inconvénient est que si, entre l'attribution et la suppression de sp de créer un autre shared_ptr qui partage la propriété de l'objet, de la suppression de sp n'entraînera pas la suppression de l'objet, cela ne sera possible que lorsque le compteur de référence de l'objet passe à 0.

  2. 5

    [Edit: vous pouvez delete un shared_ptr si et seulement si il a été créé avec newde même que tout autre type. Je ne vois pas pourquoi vous devez créer un shared_ptr avec newmais rien ne peut vous arrêter.]

    Bien, vous pourrait écrire delete ptr.get();.

    Le faire conduit presque inévitablement à un comportement indéfini, soit lors de la autres partagé propriétaires de leur shared_ptr pour accéder à l'objet supprimé, ou le dernier shared_ptr de l'objet est détruit, et l'objet est supprimé de nouveau.

    Donc, non, vous ne devriez pas.

    Le but de shared_ptr est de gérer un objet que pas une seule "personne" a le droit ou la responsabilité à supprimer, car il pourrait y avoir d'autres le partage de la propriété. Si vous ne voulez pas jamais.

  3. 2

    Vous ne pouvez pas forcer son nombre de références à zéro, aucune.

    Penser à ce qui serait nécessaire pour que cela fonctionne. Vous auriez besoin d'aller à chaque lieu le shared_ptr est utilisé et clair.

    Si vous n'avez vigueur le pointeur partagé de supprimer et de le régler à la valeur NULL, il serait juste comme un weak. Cependant, tous ces endroits dans le code à l'aide que shared_ptr ne sont pas prêt pour ça, et attendre d'être en possession d'un permis de pointeur. Ils n'ont aucune raison de vérifier la valeur NULL, et si ces bouts de code crash.

  4. 1

    Si vous voulez simuler le comte de décrémentation, vous pouvez le faire manuellement sur le tas comme suit:

    int main(void) {
    std::shared_ptr<std::string>* sp = new std::shared_ptr<std::string>(std::make_shared<std::string>(std::string("test")));
    std::shared_ptr<std::string>* sp2 = new std::shared_ptr<std::string>(*sp);
    delete sp;

    std::cout << *(*sp2) << std::endl;    //test
    return 0;
}

    Ou sur la pile à l'aide std::shared_ptr::reset() comme suit:

    int main(void) {
    std::shared_ptr<std::string> p = std::make_shared<std::string>(std::string("test"));
    std::shared_ptr<std::string> p2 = p;
    p.reset();

    std::cout << *p2 << std::endl;    //test
    return 0;
}

    Mais il n'est pas utile.

  5. 0

    Expliticly suppression est très pratique dans certains (très?) de rares cas.

    En plus explicitement la suppression, vous devez parfois explicitement détruire un pointeur partagé lorsque vous êtes à la suppression de la " il!

    Les choses peuvent devenir bizarre lors de l'interfaçage avec du code C, le passage d'un shared_ptr comme opaque valeur.

    Par exemple j'ai le texte suivant pour le passage des objets et du langage de script Lua qui est écrit en C. (www.lua.org)

    static void push( lua_State *L, std::shared_ptr<T> sp )
{
    if( sp == nullptr ) {
        lua_pushnil( L );
        return;
    }

    //This is basically malloc from C++ point of view.
    void *ud = lua_newuserdata( L, sizeof(std::shared_ptr<T>));

    //Copy constructor, bumps ref count.
    new(ud) std::shared_ptr<T>( sp );

    luaL_setmetatable( L, B::class_name );
}

    Donc c'est un shared_ptr dans certains malloc avais de la mémoire. L'inverse est de... (le programme d'installation pour être appelé juste avant de Lua ordures recueille un objet et " free).

    static int destroy( lua_State *L )
{
    //Grab opaque pointer
    void* ud = luaL_checkudata( L, 1, B::class_name );

    std::shared_ptr<T> *sp = static_cast<std::shared_ptr<T>*>(ud);

    //Explicitly called, as this was 'placement new'd
    //Decrements the ref count
    sp->~shared_ptr();

    return 0;
}