Comprendre les limites de shared_from_this dans les constructeurs
Comme indiqué dans l'extrait de « La bibliothèque standard C », shared_from_this() est confronté à un problème technique limitation au sein des constructeurs. Pour comprendre ce concept, il est essentiel de se plonger dans le fonctionnement interne de shared_from_this().
Le rôle des pointeurs faibles dans shared_from_this
shared_from_this() repose sur un système interne faible_ptr pour conserver une référence faible à l'objet créé. Ce pointeur faible reste non initialisé jusqu'à ce qu'un shared_ptr fort (un shared_ptr propriétaire de l'objet) soit créé pour l'objet. Ce n'est qu'après l'instanciation du premier shared_ptr que l'enable_shared_from_this, une classe de base de l'objet, peut accéder à ce shared_ptr et initialiser le low_ptr.
Le problème du timing de construction
Cette dépendance sur shared_ptrs existant pose un problème pour les constructeurs. Lorsqu'un constructeur est invoqué, aucun shared_ptr pointant vers l'objet en cours de construction n'existe encore. Par conséquent, pendant la construction, activate_shared_from_this ne peut pas initialiser son faible_ptr, ce qui rend shared_from_this() inutilisable dans le constructeur.
Un exemple de clarification
Considérez l'extrait de code suivant :
class Person : public std::enable_shared_from_this<Person> { ... }; std::shared_ptr<Person> p(new Person());
Dans cet exemple, le constructeur de Person() s'exécute avant le constructeur du shared_ptr p. Cela signifie que pendant le constructeur Person(), aucun shared_ptr pointant vers l'objet Person n'existe, interdisant à enable_shared_from_this d'initialiser son low_ptr et rendant shared_from_this() inaccessible dans le constructeur.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!