Comment rompre la référence cyclique shared_ptr en utilisant faible_ptr

J’ai lu que point faible peut être utilisé pour rompre les références cycliques.

Prenons l’exemple suivant d’une référence cyclique

struct A { boost::shared_ptr shrd_ptr; }; boost::shared_ptr ptr_A(boost::make_shared()); boost::shared_ptr ptr_b(boost::make_shared()); ptr_A->shrd_ptr = ptr_b; ptr_b->shrd_ptr = ptr_A; 

Maintenant ci-dessus est un cas de référence cyclique et je voulais savoir comment je peux casser la référence cyclique ci-dessus en utilisant weak_ptr ?

Mise à jour: Sur la base des suggestions reçues, j’ai proposé ce qui suit:

 struct A { boost::weak_ptr wk_ptr; }; boost::shared_ptr ptr_A (boost::make_shared()); boost::shared_ptr ptr_B (boost::make_shared()); ptr_A->wk_ptr = ptr_B; ptr_B->wk_ptr = ptr_A; 

Sera-ce la bonne approche?

L’exemple classique de références cycliques est celui où vous avez deux classes A et BA a une référence à B qui a une référence à A :

 #include  #include  struct B; struct A { std::shared_ptr b; ~A() { std::cout << "~A()\n"; } }; struct B { std::shared_ptr a; ~B() { std::cout << "~B()\n"; } }; void useAnB() { auto a = std::make_shared(); auto b = std::make_shared(); a->b = b; b->a = a; } int main() { useAnB(); std::cout << "Finished using A and B\n"; } 

Si les deux références sont shared_ptr cela shared_ptr que A a la propriété de B et B a la propriété de A , ce qui devrait faire sonner l'alarme. En d'autres termes, A garde B vie et B maintient A vie.

Dans cet exemple, les instances a et b ne sont utilisées que dans la fonction useAnB() . Nous souhaitons donc qu'elles soient détruites à la fin de la fonction, mais comme nous pouvons le constater lors de l'exécution du programme, les destructeurs ne sont pas appelés.

La solution consiste à décider qui possède qui. Disons que A possède B mais B ne possède pas A alors nous remplaçons la référence à A dans B par un weak_ptr comme weak_ptr :

 struct B { std::weak_ptr a; ~B() { std::cout << "~B()\n"; } }; 

Ensuite, si nous exécutons le programme, nous voyons que a et b sont détruits comme prévu.

Démo en direct

Edit: Dans votre cas, l'approche que vous avez suggérée semble parfaitement valide. Enlevez la propriété de A et quelque chose d'autre appartient aux A s.