Comment fait-on abattu un std::shared_ptr?

Considérer:

struct SomethingThatsABase
{
    virtual bool IsChildOne() const { return false; }
    virtual bool IsChildTwo() const { return false; }
};

struct ChildOne : public SomethingThatsABase
{
    virtual bool IsChildOne() const { return true; }
};

struct ChildTwo : public SomethingThatsABase
{
    virtual bool IsChildTwo() const { return true; }
};

void SomeClientExpectingAChildOne(std::shared_ptr<ChildOne> const& ptrOne)
{
    //Does stuff
}

void SomeClient(std::shared_ptr<SomethingThatsABase> const& ptr)
{
    if (ptr->IsChildOne())
    {
        SomeClientExpectingAChildOne(ptr); //Oops.
        //Hmm.. can't static_cast here, because we need a `shared_ptr` out of it.
    }
}

(Note que je ne peux pas tout simplement faire un std::shared_ptr<ChildOne>(static_cast<ChildOne*>(ptr.get())), parce que le nombre de références ne sont pas partagés entre les deux shared_ptrs)

InformationsquelleAutor Billy ONeal | 2011-07-22
  1. 91

    Cela devrait fonctionner:

    if (ptr->IsChildOne())
{
    SomeClientExpectingAChildOne(std::static_pointer_cast<ChildOne>(ptr));
}
    • Parfait! +1. (Et, probablement, le "vert plié à angle chose" bientôt trop)
    • +1 - je n'étais pas au courant de std::static_pointer_cast! Comment cela fonctionne, ne retournés shared_ptr agir comme un proxy de sorte que les deux partagé les pointeurs de maintenir le même nombre de références ou pas?
    • Un shared_ptr a deux pointeurs, l'une pour l'objet partagé, et un pour le bloc avec le fort et le faible nombre de références. Deux shared_ptrs de types différents peuvent partager le fort et le faible nombre de références de blocs sans difficulté. Ma conjecture est qu'il est mis en œuvre avec static_pointer_cast être un friend de shared_ptr, mais bien sûr, votre application peut varier.
    • J'ai toujours utilisé des shared_dynamic_cast en Boost. Apparemment dynamic_pointer_cast est plus générique, cependant, car il fonctionne avec différents types de pointeurs (shared_ptr, raw pointeurs, intrusive_ptr, et potentiellement autre chose dans le futur).
    • probablement, il utilise le aliasing constructor, (ref, ptr) créer un shared_pointer copie de ref mais pointant vers ptr.
    InformationsquelleAutor mwigdahl
  2. 34

    La shared_ptr équivalent de static_cast est static_pointer_cast, et la shared_ptr équivalent de dynamic_cast est dynamic_pointer_cast.

    • J'étais pas au courant de ces deux, je suis donc allé à la recherche pour certains documentation. Des trucs Cool!
    InformationsquelleAutor Joel
  3. 21

    À partir de C++11, §20.10.2.2.9 ([util.smartptr.partagé.fonte]) de la norme C++ indique les équivalents de static_cast, const_cast et dynamic_cast pour std::shared_ptr comme suit:

    std::static_pointer_cast:

    template <class T, class U>
shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r) noexcept;

    static_pointer_cast nécessite static_cast<T *>(r.get()) d'être bien formés. Si r est vide, un vide shared_ptr<T> est renvoyé, sinon retourne un pointeur w le partage de la propriété avec r où w.get() == static_cast<T *>(r.get()) et w.use_count() == r.use_count().

    std::const_pointer_cast:

    template <class T, class U>
shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r) noexcept;

    const_pointer_cast a les mêmes exigences et la sémantique de static_pointer_cast, sauf que const_cast est utilisé à la place de static_cast.

    std::dynamic_pointer_cast:

    template <class T, class U>
shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r) noexcept;

    dynamic_pointer_cast est un peu différent car elle nécessite dynamic_cast<T *>(r.get()) d'être bien formés et ont bien défini de la sémantique. Si dynamic_cast<T *>(r.get()) est une valeur non nulle, retourne un pointeur w le partage de la propriété avec r où w.get() == dynamic_cast<T *>(r.get()) et w.use_count() == r.use_count(), sinon un vide shared_ptr<T> est retourné.

    std::reinterpret_pointer_cast:

    Pour C++17, N3920 (adoptée en Bibliothèque Fondamentaux TS en février 2014) a également proposé un std::reinterpret_pointer_cast similaire à ci-dessus, qui n'aurait besoin que d' reinterpret_cast<T *>((U *) 0) d'être bien formés et retourne shared_ptr<T>(r, reinterpret_cast<typename shared_ptr<T>::element_type *>(r.get())). Note N3920 également modifié le libellé de l'autre shared_ptr jette et étendu shared_ptr à l'appui de tableaux.

    InformationsquelleAutor jotik