Pourquoi ne pouvez-vous pas utiliser `shared_from_this()` dans les constructeurs ?

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!