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. |
| Déclaré dans l'en-tête <memory>
|
||
| template< class T > class enable_shared_from_this; |
(depuis C++11) | |
std::enable_shared_from_this permet une t objet qui est actuellement géré par un std::shared_ptr nommé pt en toute sécurité de générer 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.
Héritant 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 géré par un std::shared_ptr<T> nommé pt, puis T::shared_from_this appel renverra une nouvelle std::shared_ptr<T> qui partage la propriété 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 possède 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'entraîner des this étant détruit plus d'une fois par plusieurs propriétaires 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.
Sommaire |
[modifier] 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 protégée) | |
| détruit 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 protégée) | |
| renvoie une référence à 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 protégée) | |
| retourne un shared_ptr qui partage la propriété 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) | |
[modifier] Notes
Une mise en œuvre commune pour
enable_shared_from_this est de maintenir une référence faible (comme std::weak_ptr) à this. Les constructeurs de std::shared_ptr peut détecter la présence d'une base enable_shared_from_this et l'actionnariat des std::shared_ptrs existants, au lieu de supposer le pointeur n'est pas géré 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.
[modifier] 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
Résultat :
gp2.use_count() = 2 bp2.use_count() = 1 Bad::~Bad() called Bad::~Bad() called *** glibc detected *** ./test: double free or corruption
[modifier] Voir aussi
| (C++11) |
pointeur intelligent avec sémantique de propriétaires partagés (classe générique) |
