Recount

"Zouplaz" <pouet@pouet.com> a écrit dans le message de
news:Xns9414E87ADCD65Zoupla@213.228.0.136...

Bonjour, allez il faut que je progresse, il FAUT que j'arrive à comprendre
le principe des refcounts. J'ai eu beau lire quelques articles et voir
même

mettre mon nez dans je ne sais plus quel template ANSI je n'arrive pas à
comprendre quelle magie se cache derrière...

Pourriez-vous me donner une ou deux pistes, je suis sur que le déclic va
se

produire ;-)

Par piste, ça peut aussi être un lien vers un site francophone.

Merci

Kesako refcounts ? Compteur de référence ?

Zouplaz wrote:

Bonjour, allez il faut que je progresse, il FAUT que j'arrive à
comprendre le principe des refcounts. J'ai eu beau lire quelques
articles et voir même mettre mon nez dans je ne sais plus quel
template ANSI je n'arrive pas à comprendre quelle magie se cache
derrière...

Pourriez-vous me donner une ou deux pistes, je suis sur que le déclic
va se produire ;-)

Le comptage de référence a pour principal objet de partager une ressource
entre plusieurs instances. La ressource doit être acquise dès qu'une
instance en a l'usage, et doit être libérée dès qu'aucune ne s'en sert plus.

En C++, typiquement, on se sert des constructeurs, destructeurs, et
opérateurs d'affectation pour respectivement incrémenter le compteur, le
décrémenter, ou les deux.

Dès que le compteur passe à zéro dans un destructeur ou operateur
d'affectation, on libère la ressource.

Mais c'est un peu général, et peut-être le mieux est que tu poses une
question plus précise...

Chris

Bonjour, allez il faut que je progresse, il FAUT que j'arrive à comprendre
le principe des refcounts. J'ai eu beau lire quelques articles et voir
même mettre mon nez dans je ne sais plus quel template ANSI je n'arrive
pas à comprendre quelle magie se cache derrière...

<avertissement>
merci de m'arrêter si je raconte n'importe quoi, il est tard ! :-)
</avertissement>

Le principe du "reference counting" (comptage de références), c'est de
déléguer la destruction d'un objet à lui-même.

Ainsi, tu n'as pas besoin de savoir quand détruire l'objet, ni de te soucier
de savoir si d'autres parties du code l'utilisent (dans le cas de données
partagées) : tu ne fais que t'approprier une référence sur l'objet, et tu
libère cette référence une fois que tu en as terminé avec.

Un exemple classique d'utilisation de données partagées entre des objets :

// Compteur de référence
class ref_count
{
protected:

virtual ~ref_count() { }

public:

ref_count() : m_count(1) { }

void addRef() { ++m_refCount; }
void release() { if (--m_refCount == 0) delete *this; }

private:

int m_count;
};

// Données de l'objet
class donnees : public ref_count
{
protected:

~donnees() { }

public:

donnees();
};

class objet
{
public:

objet() : m_donnees(new donnees) { } // création
~objet() { m_donnees->release(); } // libération

objet(const objet& o)
{
m_donnees = o.m_donnees;
m_donnees->addRef();
}

objet& operator=(const objet& o)
{
m_donnees->release(); // plus besoin des anciennes données
m_donnees = o.m_donnees;
m_donnees->addRef(); // ajout d'une référence
}

void modify()
{
m_donnees->release(); // libération des anciennes données
m_donnees = new donnees; // création de nouvelles données
// ...
}

private:

donnees* m_donnees;
};


objet o1; // création données 1 + ajout de référence
objet o2; // création données 2 + ajout de référence

objet o3 = o2; // ajout de référence sur données 2
objet o4 = o3; // ajout de référence sur données 2
objet o5 = o1; // ajout de référence sur données 1

o4.modify(); // libération référence données 2 + création données 3
// + ajout de référence sur données 3

Après la création d'o5, les données 1 sont référencées 2 fois (m_count = 2)
Quand o5 sera détruit, données 1 n'auront plus qu'1 référence : m_count = 1
Quand o1 sera détruit, données 1 seront détruites (delete) car m_count = 0

Lors de la copie d'un "objet", pour éviter de copier les données, on garde
seulement une référence dessus. On libère cette référence à la destruction
de l'objet (ou à sa modification car dans ce cas les données ne sont plus
communes).

Dès que tous les objets qui utilisaient une même donnée ont chacun libéré
leur référence (via release()), les données sont automatiquement détruites.

J'ai déjà vu des utilisations de ce type pour le COW (copy-on-write) de
classes gérant des chaînes de caractères (deux chaînes de caractères
partagent le même buffer si elles sont identiques ; dès que l'une des deux
est modifiée, une copie du buffer est réalisée, l'ancien buffer est
déréférencé avant d'effectuer la modification sur la copie).

Vincent

--
vmime, une bibliothèque C++ sous licence GPL pour parser et générer
des messages au format MIME : http://www.sourceforge.net/projects/vmime/

Zouplaz <pouet@pouet.com> wrote in message
news:<Xns9414E87ADCD65Zoupla@213.228.0.136>...

allez il faut que je progresse, il FAUT que j'arrive à comprendre le
principe des refcounts. J'ai eu beau lire quelques articles et voir
même mettre mon nez dans je ne sais plus quel template ANSI je
n'arrive pas à comprendre quelle magie se cache derrière...

Je suppose que tu veux dire le comptage des références. Alors, ce n'est
pas ANSI ni ISO (encore, en tout cas, et j'espère jamais). Et il n'y a
rien de magique.

Pourriez-vous me donner une ou deux pistes, je suis sur que le déclic
va se produire ;-)

Par piste, ça peut aussi être un lien vers un site francophone.

Francophone, je ne sais pas. Comme implémentations tout faites, il y a
bien Boost (shared_ptr), mais aussi chez moi (mon RefCntPtr est une des
classes avec une documentation bilangue chez moi), ou pour une bonne
explication, la bibliothèque OSE (http://www.dscpl.com.au, va à la page
de Resource Management dans le manuel de la bibliothèque).

Comme littérature, voir surtout Scott Meyers (« More Effective C++ ») ou
Barton et Nackman, pour deux implémentations différentes. (Tu dois avoir
le Meyers et l'avoir lu de toute façon.)

Et oui, la plupart de la documentation est en anglais.

--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16

Vincent Richard - chere-loque.MARRE-DE-LA-PUB@wanadoo.fr.invalid :

<avertissement>
merci de m'arrˆter si je raconte n'importe quoi, il est tard ! :-)
</avertissement>

Bonsoir et merci pour ta longue réponse (et également aux autres posteurs).

Je commence à comprendre mais c'est toujours pas tout à fait ça, je vais
bien relire ton message afin de poser la question FINALE, celle qui me
permettra de tout piger et surtout de savoir si le comptage de références
est la solution à mon problème.

le Tuesday 14 October 2003 22:48, pouet@pouet.com écrivit :

Pourriez-vous me donner une ou deux pistes, je suis sur que le déclic va
se produire ;-)

ya rien de sorcier, des pointeurs avec comptage de référence s'utilisent
schématiquement comme ça :

imaginons qu'on ait un template de classe RefCountPtr<class T>
et une classe Objet que l'on veut manipuler par pointeur avec comptage de
référence (pour ne pas avoir à faire le delete soit même, par exemple)

{
typedef RefCountPtr<Objet> refptr;
refptr p1(new Objet); // créé un pointeur vers un nouvel Objet,
// le stocke dans p1,
// et initialise un compteur à 1, qque part.
{
refptr p2 = p1; // copie l'adresse, pas l'objet
// lors de la copie, la classe RefCountPtr incrémente le compteur.

} // p2 est détruit. le destructeur regarde le compteur,
// et appelle delete si besoin, sinon se contente de décrémenter le
// compteur.
// Donc là, il se contente de décrémenter

} // p1 est détruit, cette fois ça entraine un appel à delete.


C'est un 'pointeur intelligent', on le charge de la destruction de l'objet
créé et de la désallocation de la mémoire lorsqu'il le faut.

--
Sam

Samuel Krempp - krempp@crans.truc.en.trop.ens-cachan.fr :

le Tuesday 14 October 2003 22:48, pouet@pouet.com écrivit :

Pourriez-vous me donner une ou deux pistes, je suis sur que le déclic
va se produire ;-)

ya rien de sorcier, des pointeurs avec comptage de référence
s'utilisent schématiquement comme ça :

imaginons qu'on ait un template de classe RefCountPtr<class T>
et une classe Objet que l'on veut manipuler par pointeur avec comptage
de référence (pour ne pas avoir à faire le delete soit même, par
exemple)

Alors, voila on y est ! C'est justement pour ne plus avoir à faire de
delete sur certains objets (c'est une sorte de garbage collector
simplifié ça ?)

{
typedef RefCountPtr<Objet> refptr;
refptr p1(new Objet); // créé un pointeur vers un nouvel Objet,
// le stocke dans p1,
// et initialise un compteur à 1, qque part.
{
refptr p2 = p1; // copie l'adresse, pas l'objet
// lors de la copie, la classe RefCountPtr incrémente le compteur.

} // p2 est détruit. le destructeur regarde le compteur,
// et appelle delete si besoin, sinon se contente de décrémenter le
// compteur.
// Donc là, il se contente de décrémenter

} // p1 est détruit, cette fois ça entraine un appel à delete.


C'est un 'pointeur intelligent', on le charge de la destruction de
l'objet créé et de la désallocation de la mémoire lorsqu'il le faut.

Ah, je vois bien là... Ca voudrait dire, par exemple, que si des objets
dont le scope est une méthode (locaux) sont alloués dynamiquement (par
new) je n'aurais pas besoin de faire de delete avant de sortir de la
méthode (ou fonction) ?

Zouplaz wrote:

C'est un 'pointeur intelligent', on le charge de la destruction de
l'objet créé et de la désallocation de la mémoire lorsqu'il le faut.

Ah, je vois bien là... Ca voudrait dire, par exemple, que si des
objets dont le scope est une méthode (locaux) sont alloués
dynamiquement (par new) je n'aurais pas besoin de faire de delete
avant de sortir de la méthode (ou fonction) ?

Oui c'est ça. C'est le destructeur du pointeur intelligent qui, quand il
verra que son refcount est à 0 après l'avoir décrémenté, prendra la décision
de faire delete.
--
<=- Michaël "Cortex" Monerau -=>

Michaël Monerau wrote:

Oui c'est ça. C'est le destructeur du pointeur intelligent qui, quand il
verra que son refcount est à 0 après l'avoir décrémenté, prendra la décision
de faire delete...

... Ou tout autre fonction charger de detruire l'objet pointé.


A+

LD

On 15 Oct 2003 18:40:30 GMT, Zouplaz <pouet@pouet.com> wrote:

Je commence à comprendre mais c'est toujours pas tout à fait ça, je vais
bien relire ton message afin de poser la question FINALE

Pas la peine de la poster, on sait déjà que la réponse est 42.

--
http://www.giromini.org/usenet-fr/repondre.html