Discussion :

[guillaume07]

une petite question :

dans le code de boost::shared_ptr l'operateur d'affectation est defini ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
    shared_ptr & operator=(shared_ptr const & r) // never throws
    {
        px = r.px;
        pn = r.pn; // shared_count::op= doesn't throw
        return *this;
    }

Pourquoi pas de swap ici ?

[koala01]

Parce que, justement, le but poursuivi par un shared_ptr est d'assurer qu'une adresse mémoire est correctement partagée entre deux instances deux celui-ci.

Ce qui se passe avec le shared_ptr, c'est que tu as un compteur de référence (c'est en réalité une valeur numérique déclarée statique, de manière à s'assurer que toutes les instances de shared_ptr utilisent la même), incrémentée lors de la copie et décrémentée lors de la destruction.

La libération de la mémoire n'intervenant que lorsque ce compteur de référence revient à 0 dans le destructeur

Pour avoir confirmation de ce que j'expose, regarde:
1- la définition de shared_ptr (tu y trouvera une variable statique)
2- le constructeur par copie du shared_ptr (tu remarquera l'incrémentation de la variable statique)
3- le destructeur du shared_ptr (tu y remarquera la décrémentation de la variable statique, et que la libération du pointeur s'effectue si... la variable statique est à 0 )

[Invité]

Sauf erreur la variable n'est pas statique puisqu'un code tel que celui est possible :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
int main()
{
   shared_ptr<int> ptr1(new int(524));//compteur == 1
   shared_ptr<int> ptr2(new int(123));//compteur == 2
}//~ptr2 compteur == 1
//~ptr1 compteur == 0;

Si on utilisait une variable statique ptr2 ne serait pas détruit(puisque le compteur est encore à 1).

[koala01]

Et pourtant, c'est le seul moyen d'assurer un comptage de référence correct et cohérent (autrement, tu risquerais de voir la mémoire allouée libérée lors de la destruction du premier objet créé, alors que les suivant sont encore utilisés )

Maintenant, je n'ai pas été vérifier le code, mais je ne serais pas étonné qu'il y ait une "astuce" quelconque grâce à l'utilisation des template

[guillaume07]

oui je pense pas que ça soit static

[Goten]

Sauf erreur la variable n'est pas statique puisqu'un code tel que celui est possible :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
int main()
{
   shared_ptr<int> ptr1(new int(524));//compteur == 1
   shared_ptr<int> ptr2(new int(123));//compteur == 2
}//~ptr2 compteur == 1
//~ptr1 compteur == 0;

Si on utilisait une variable statique ptr2 ne serait pas détruit(puisque le compteur est encore à 1).

Ben si c'est le principe d'un compteur de référence. (basiquement, y'a des trucs plus compliqué dans l'implémentation de boost). Un compteur statique, et le dtor / ctor etc décrémente / incrémente la variable

[guillaume07]

Sauf erreur la variable n'est pas statique puisqu'un code tel que celui est possible :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
int main()
{
   shared_ptr<int> ptr1(new int(524));//compteur == 1
   shared_ptr<int> ptr2(new int(123));//compteur == 2
}//~ptr2 compteur == 1
//~ptr1 compteur == 0;

Si on utilisait une variable statique ptr2 ne serait pas détruit(puisque le compteur est encore à 1).

Mais là on a deux pointeurs distincts ...
On a un seul compteur ? pas deux ?

[Goten]

Deux.

[guillaume07]

[gl]

Et pourtant, c'est le seul moyen d'assurer un comptage de référence correct et cohérent (autrement, tu risquerais de voir la mémoire allouée libérée lors de la destruction du premier objet créé, alors que les suivant sont encore utilisés )

Maintenant, je n'ai pas été vérifier le code, mais je ne serais pas étonné qu'il y ait une "astuce" quelconque grâce à l'utilisation des template

Je viens de jeter un coup d'oeil rapide et apparemment non, il n'y a pas de static ni "d'astuce" à coup de template.

Le shared pointer contient juste un pointeur sur le compteur de référence.

dans le code de boost::shared_ptr l'operateur d'affectation est defini ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
    shared_ptr & operator=(shared_ptr const & r) // never throws
    {
        px = r.px;
        pn = r.pn; // shared_count::op= doesn't throw
        return *this;
    }

Pourquoi pas de swap ici ?

Tout d'abord, px étant un simple pointeur l'affectation ne lève pas d'exception et au vu du commentaire, l'affectation de pn ne throw pas non plus, la simple affectation comme ici fonctionne bien.

En outre dans la version 1.43 (la dernière) de boost, l'opérateur d'affectation de boost::shared_ptr est bel et bien implémenter via le copy and sawp.

[3DArchi]

Je n'ai pas pris le temps de revérifier mais je suis rassuré par la réponse de gl. Je ne vois pas trop l'intérêt d'une variable statique. Le compteur de référence est, si ma mémoire ne me trahi pas trop, un compteur alloué dynamiquement et associé aux différentes instances de shared_ptr qui partagent le même pointeur. D'ailleurs, intuitivement, c'est comme ça que je procéderais au premier abord.

[Goten]

Ouaip c'est ça. Autant pour moi, j'avais laissé le cerveau à coté du clavier.

[guillaume07]

ça arrive