std::enable_shared_from_this
Da cppreference.com.
 |
Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate.
La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui. |
| Elemento definito nell'header <memory>
|
||
| template< class T > class enable_shared_from_this; |
(dal C++11) | |
std::enable_shared_from_this permette un t oggetto che è attualmente gestito da un std::shared_ptr nome pt per generare in modo sicuro altre istanze std::shared_ptr pt1, pt2, ... che tutti azionariato di t con pt.Original:
std::enable_shared_from_this allows an object t that is currently managed by a std::shared_ptr named pt to safely generate additional std::shared_ptr instances pt1, pt2, ... that all share ownership of t with pt.The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
You can help to correct and verify the translation. Click here for instructions.
Eredità da
std::enable_shared_from_this<T> fornisce un T tipo con shared_from_this funzione membro. Se un oggetto di t T tipo è gestito da un std::shared_ptr<T> nome pt, quindi T::shared_from_this chiamata restituirà un nuovo std::shared_ptr<T> che la proprietà di parti t con pt.Original:
Inheriting from
std::enable_shared_from_this<T> provides a type T with a member function shared_from_this. If an object t of type T is managed by a std::shared_ptr<T> named pt, then calling T::shared_from_this will return a new std::shared_ptr<T> that shares ownership of t with pt.The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
You can help to correct and verify the translation. Click here for instructions.
Notare che prima di chiamare
shared_from_this su un t oggetto, ci deve essere un std::shared_ptr che possiede t.Original:
Note that prior to calling
shared_from_this on an object t, there must be a std::shared_ptr that owns t.The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
You can help to correct and verify the translation. Click here for instructions.
Si noti inoltre che
enable_shared_from_this fornisce un'alternativa a un'espressione come std::shared_ptr<T>(this), che è suscettibile di provocare this stati distrutti più di una volta da più proprietari che non sono a conoscenza della vicenda.Original:
Also note that
enable_shared_from_this provides an alternative to an expression like std::shared_ptr<T>(this), which is likely to result in this being destructed more than once by multiple owners that are unaware of eachother.The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
You can help to correct and verify the translation. Click here for instructions.
Indice |
[modifica] Membri funzioni
| costruisce un oggetto enabled_shared_from_this Original: constructs an enabled_shared_from_this object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (protetto funzione membro) | |
| distrugge un oggetto enable_shared_from_this Original: destroys an enable_shared_from_this object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (protetto funzione membro) | |
| restituisce un riferimento this Original: returns a reference to this The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (protetto funzione membro) | |
| restituisce un shared_ptr che condivide la proprietà di *this Original: returns a shared_ptr which shares ownership of *this The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico) | |
[modifica] Note
Un'implementazione comune per
enable_shared_from_this è quello di tenere un riferimento debole (come std::weak_ptr) a this. I costruttori di std::shared_ptr in grado di rilevare la presenza di una base enable_shared_from_this e gli assetti proprietari con i std::shared_ptrs esistenti, invece di assumere il puntatore non è gestito da nessun altro.Original:
A common implementation for
enable_shared_from_this is to hold a weak reference (such as std::weak_ptr) to this. The constructors of std::shared_ptr can detect presence of a enable_shared_from_this base and share ownership with the existing std::shared_ptrs, instead of assuming the pointer is not managed by anyone else.The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
You can help to correct and verify the translation. Click here for instructions.
[modifica] Esempio
#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
[modifica] Vedi anche
| (C++11) |
smart pointer with shared object ownership semantics (classe template) |
