std::enable_shared_from_this
De cppreference.com
 [] |
This page has been machine-translated from the English version of the wiki using Google Translate.
The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here. |
![[]](https://upload.cppreference.com/mwiki/images/3/31/Imbox_notice.png){kind=link}
<metanoindex/>
<tbody> </tbody>| Dclar dans l'en-tte <memory>
|
||
template< class T > class enable_shared_from_this; |
(depuis C++11) | |
std::enable_shared_from_this permet une t objet qui est actuellement gr par un std::shared_ptr nomm pt en toute scurit de gnrer d'autres instances std::shared_ptr pt1, pt2, ... que tout l'actionnariat de t avec 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.
Hritant de
std::enable_shared_from_this<T> fournit une T type avec une shared_from_this fonction membre. Si un objet de t T type est gr par un std::shared_ptr<T> nomm pt, puis T::shared_from_this appel renverra une nouvelle std::shared_ptr<T> qui partage la proprit avec des t 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.
Notez que avant d'appeler
shared_from_this sur une t objet, il doit y avoir un std::shared_ptr qui possde 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.
A noter galement que
enable_shared_from_this offre une alternative une expression comme std::shared_ptr<T>(this), qui est susceptible d'entraner des this tant dtruit plus d'une fois par plusieurs propritaires qui ne sont pas au courant de eachother .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.
Fonctions membres
construit un objet 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. (fonction membre protge) | |
dtruit un objet 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. (fonction membre protge) | |
renvoie une rfrence 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. (fonction membre protge) | |
retourne un shared_ptr qui partage la proprit de *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. (fonction membre publique) | |
Notes
Une mise en uvre commune pour
enable_shared_from_this est de maintenir une rfrence faible (comme std::weak_ptr) this. Les constructeurs de std::shared_ptr peut dtecter la prsence d'une base enable_shared_from_this et l'actionnariat des std::shared_ptrs existants, au lieu de supposer le pointeur n'est pas gr par quelqu'un d'autre .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.
Exemple
#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
Rsultat :
gp2.use_count() = 2
bp2.use_count() = 1
Bad::~Bad() called
Bad::~Bad() called
*** glibc detected *** ./test: double free or corruption
Voir aussi
(C++11) |
pointeur intelligent avec smantique de propritaires partags (classe gnrique) |