Shared_ptr - operator pretypovani – C / C++ – Fórum – Programujte.com

ahojky,
tak prvni dotaz na nove forum

shared_ptr<T> nema pretizeny operator pretypovani T*. Nejak jsem si uvedomil, ze ho potrebuji . Existuje v standardu nejaka podobna trida, ktera implementuje i "operator T*()?"
Dekuji moc vsem za odpovedi.

Koudis

Přetypování? Myslíš metodu, která vrátí obyčejný ukazatel? Ta se jmenuje get(). Pokud myslíš něco jiného, tak to rozveď.

#2 ondra.holub
Ahoj,

nene, vim ze shared_ptr ma metodu get(). Ja potrebuji, aby mela i clenskou metodu "operator T*()?" // je celkem logicke, ze ji shared_ptr nema // 

Koudis

Z jakého důvodu? Aby ti vracela přímo hodnotu?

#3 Koudis
Jestli jde jenom o to, aby se ten shared_ptr dal předávat jako parametr funkcím, které požadují obyčejný ukazatel, tak tam musíš strčit ten get. Pokud se totiž začnou mixovat "chytré" ukazatele s obyčejnými, tak je potřeba to dělat s rozmyslem a člověk musí vědět přesně, co se uvnitř té funkce děje. Ta funkce může na ten (obyčejný) ukazatel zavolat třeba delete nebo z něj může udělat další instanci chytrého ukazatele. To obvykle rozbije celý mechanismus reference countingu a program nakonec začne padat - obvykle na naprosto nečekaném místě.

Jak píšeš, je logické, že tento operátor tam není.

#3 Koudis
Pořád si ještě můžeš udělat vlastní třídu zděděnou ze std::shared_ptr. Jenom znovu opíšeš konstruktory a přidáš ten operátor přetypování.

template<typename T>
class my_shared_ptr: public std::shared_ptr<T>
{
    typedef
        std::shared_ptr<T> Base;

public:
    explicit my_shared_ptr(T* ptr): Base(ptr) { }

    operator T*()
    {
        return Base::get();
    }

    operator const T*() const
    {
        return Base::get();
    }

};

Ale je třeba si uvědomit nebezpečí, která jsem zmínil v předešlé odpovědi.

#6 ondra.holub
prepisovat konstruktory asi moc pekna vec nebude. Lepsi bude, hodit do tridy jako clenskou promennou ukazetal na shared_ptr...

Me spise zajimalo, jestli nejaka takove trida neexistuje primo v STL. Abych ji nemusel zbytecne psat...

Koudis

#7 Koudis
Ukazatel na shared_ptr? Proč ukazatel? To nějak popírá smysl toho shared_ptr.

> Me spise zajimalo, jestli nejaka takove trida neexistuje primo v STL.

No, možná existuje - určitě nejsem super znalec STL. Ale nevím o ní a tipnul bych si, že s výše zmíněných důvodů tam ani nebude.

Ale napsat si vlastní je celkem v pohodě - je to docela prima cvičení na práci se šablonami. Je možné parametrizovat variantu implementace (počítadlo uložené přímo v datech odkazovaných obyčejným ukazatelem / počítadlo někde vedle (minimálně 2 varianty) / lineární seznam všech použitých instancí místo počítadla (toto moc praktické není)). Dále lze třeba parametrizovat kontrolu na 0 ptr, zamykání...

#3 Ondra
Ukazatel na shared_ptr? Proč ukazatel? To nějak popírá smysl toho shared_ptr.

nepopira. 

template <typename T = float>
class shared_ptr_help
{
    public:
       ~shared_ptr_help() { delete shared_ptr_pointer; }
       shared_ptr_help(shared_ptr<T>* pointer): 
         shared_ptr_pointer(pointer) {}

       operator T*() { return shared_ptr_pointer->get(); }


    private:
       shared_ptr<T>* shared_ptr_pointer;
};

pak na danem miste vytvorim pomoci new nejakou instanci shared_ptr, vlozim ji do shared_ptr_help a dal se o pointer nestaram (shared_ptr_help vytvorim v "lokalnim" zasobniku).

Tato trida ma jako jedinne za ukol implementaci operatoru pretypovani. MOhli bychom pridat i metodu Getshared_ptr_pointer() const...

#9 Koudis
A k čemu je tam ten pointer na shared_ptr? Je tam zbytečná alokace, je potřeba zakázat copy construktor a operátor přiřazení a celkově to nedělá nic jiného, než toto:

template <typename T = float>
class shared_ptr_help
{
    public:
       shared_ptr_help(const shared_ptr<T>& pointer): 
         pointer(pointer) {}

       operator T*() { return pointer.get(); }


    private:
       shared_ptr<T> pointer;
};

#10 ondra.holub
to je pravda :). Ja jsem zvykli davat jine tridy jako clenske promenne pomoci ukazatele. Nejak nemam rad, ze se pouziva pri inicializaci objektu konstruktor shared_ptr<T>()...