Visualizza wikitesto di cpp/memory/enable shared from this

Non si dispone dei permessi necessari per modificare questa pagina, per il seguente motivo:
La funzione richiesta è riservata agli utenti che appartengono a uno dei seguenti gruppi: Utenti, Amministratori.
È possibile visualizzare e copiare il codice sorgente di questa pagina.
{{tr_note}}
{{cpp/title|enable_shared_from_this}}
{{cpp/memory/enable_shared_from_this/navbar}}
{{ddcl | header=memory | notes={{mark since c++11}} | 1=
template< class T > class enable_shared_from_this;
}}

{{tr|{{tt|std::enable_shared_from_this}} permette un {{tt|t}} oggetto che è attualmente gestito da un {{lc|std::shared_ptr}} nome {{tt|pt}} per generare in modo sicuro altre istanze {{lc|std::shared_ptr}} {{tt|pt1, pt2, ...}} che tutti azionariato di {{tt|t}} con {{tt|pt}}.|{{tt|std::enable_shared_from_this}} allows an object {{tt|t}} that is currently managed by a {{lc|std::shared_ptr}} named {{tt|pt}} to safely generate additional {{lc|std::shared_ptr}} instances {{tt|pt1, pt2, ...}} that all share ownership of {{tt|t}} with {{tt|pt}}.}}

{{tr|Eredità da {{tt|std::enable_shared_from_this<T>}} fornisce un {{tt|T}} tipo con {{tt|shared_from_this}} funzione membro. Se un oggetto di {{tt|t}} {{tt|T}} tipo è gestito da un {{c|std::shared_ptr<T>}} nome {{tt|pt}}, quindi {{tt|T::shared_from_this}} chiamata restituirà un nuovo {{c|std::shared_ptr<T>}} che la proprietà di parti {{tt|t}} con {{tt|pt}}.|Inheriting from {{tt|std::enable_shared_from_this<T>}} provides a type {{tt|T}} with a member function {{tt|shared_from_this}}.  If an object {{tt|t}} of type {{tt|T}} is managed by a {{c|std::shared_ptr<T>}} named {{tt|pt}}, then calling {{tt|T::shared_from_this}} will return a new {{c|std::shared_ptr<T>}} that shares ownership of {{tt|t}} with {{tt|pt}}.}}

{{tr|Notare che prima di chiamare {{tt|shared_from_this}} su un {{tt|t}} oggetto, ci deve essere un {{lc|std::shared_ptr}} che possiede {{tt|t}}.|Note that prior to calling {{tt|shared_from_this}} on an object {{tt|t}}, there must be a {{lc|std::shared_ptr}} that owns {{tt|t}}.}}

{{tr|Si noti inoltre che {{tt|enable_shared_from_this}} fornisce un'alternativa a un'espressione come {{c|std::shared_ptr<T>(this)}}, che è suscettibile di provocare {{c|this}} stati distrutti più di una volta da più proprietari che non sono a conoscenza della vicenda.|Also note that {{tt|enable_shared_from_this}} provides an alternative to an expression like {{c|std::shared_ptr<T>(this)}}, which is likely to result in {{c|this}} being destructed more than once by multiple owners that are unaware of eachother.}}

===Membri funzioni===
{{dsc begin}}
{{dsc prot mem ctor | cpp/memory/enable_shared_from_this/enable_shared_from_this |{{tr| costruisce un oggetto {{tt|enabled_shared_from_this}} | constructs an {{tt|enabled_shared_from_this}} object }}}}
{{dsc prot mem dtor | cpp/memory/enable_shared_from_this/~enable_shared_from_this |{{tr| distrugge un oggetto {{tt|enable_shared_from_this}} | destroys an {{tt|enable_shared_from_this}} object }}}}
{{dsc prot mem fun  | cpp/memory/enable_shared_from_this/operator{{=}} |{{tr| restituisce un riferimento {{c|this}} | returns a reference to {{c|this}} }}}}
{{dsc mem fun  | cpp/memory/enable_shared_from_this/shared_from_this |{{tr| restituisce un {{c|shared_ptr}} che condivide la proprietà di {{c|*this}} | returns a {{c|shared_ptr}} which shares ownership of {{c|*this}} }}}}
{{dsc end}}

===Note===
{{tr|Un'implementazione comune per {{tt|enable_shared_from_this}} è quello di tenere un riferimento debole (come {{lc|std::weak_ptr}}) a {{c|this}}. I costruttori di {{lc|std::shared_ptr}} in grado di rilevare la presenza di una base {{tt|enable_shared_from_this}} e gli assetti proprietari con i {{lc|std::shared_ptr}}s esistenti, invece di assumere il puntatore non è gestito da nessun altro.|A common implementation for {{tt|enable_shared_from_this}} is to hold a weak reference (such as {{lc|std::weak_ptr}}) to {{c|this}}. The constructors of {{lc|std::shared_ptr}} can detect presence of a {{tt|enable_shared_from_this}} base and share ownership with the existing {{lc|std::shared_ptr}}s, instead of assuming the pointer is not managed by anyone else.}}

===Esempio===
{{example
 | 
 | code=
#include <memory>
#include <iostream>

struct Good: std::enable_shared_from_this<Good>
{
    std::shared_ptr<Good> getptr() {
        return shared_from_this();
    }
};

struct Bad {
    std::shared_ptr<Bad> getptr() {
        return std::shared_ptr<Bad>(this);
    }
    ~Bad() { std::cout << "Bad::~Bad() called\n"; }
};

int main()
{
    // Good: the two shared_ptr's share the same object
    std::shared_ptr<Good> gp1(new Good);
    std::shared_ptr<Good> gp2 = gp1->getptr();
    std::cout << "gp2.use_count() = " << gp2.use_count() << '\n';

    // Bad, each shared_ptr thinks it's the only owner of the object
    std::shared_ptr<Bad> bp1(new Bad);
    std::shared_ptr<Bad> bp2 = bp1->getptr();
    std::cout << "bp2.use_count() = " << bp2.use_count() << '\n';
} // UB: double-delete of Bad
 | output=
gp2.use_count() = 2
bp2.use_count() = 1
Bad::~Bad() called
Bad::~Bad() called
*** glibc detected *** ./test: double free or corruption 
}}

===Vedi anche===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc shared_ptr}}
{{dsc end}}

[[de:cpp/memory/enable shared from this]]
[[en:cpp/memory/enable shared from this]]
[[es:cpp/memory/enable shared from this]]
[[fr:cpp/memory/enable shared from this]]
[[ja:cpp/memory/enable shared from this]]
[[pt:cpp/memory/enable shared from this]]
[[ru:cpp/memory/enable shared from this]]
[[zh:cpp/memory/enable shared from this]]
Template utilizzati in questa pagina:
Torna a cpp/memory/enable shared from this.
cppreference.com

Ricerca

Namespace

Varianti

Visite

Azioni

Visualizza wikitesto di cpp/memory/enable shared from this

Navigazione

Strumenti
