Discussion :

[Samildanach]

Bonjour,
bon j'avoue le titre est un peu bizarre mais je fais face à un petit problème et je ne vois pas trop comment faire. Alors j'explique :j'ai un objet, appelé A.
Jusque là ça va :-)

Alors le truc c'est que cet objet est utilisé partout, et le problème c'est que beaucoup d'instance sont créées sans qu'elles soient forcément détruites. Du coup, j'ai pensé ajouter à cet objet une liste qui contiendrait des pointeurs de QObject des objets qui utilise mon instance de A (par pointeur bien sur). J'espère ne pas être trop confus lol.
Ainsi, si cette liste est vide c'est que l'objet n'est utilisé par personne et donc il peut être détruit.

Mais du coup, je ne vois pas trop comment remplir cette liste à part à chaque fois que quelqu'un utilise le contact, il lui indique qui il est, mais bon c'est pas super parce que ca fait pas de lignes à rajouter

Donc la voilà où j'en suis, je ne vois pas trop comment faire

Si vous avez quelques idées je suis preneur

Merki d'avance

P.S. : c++ et Qt 4.3.2


@pluche

[yan]

Salut.
Utilise plutôt un compteur de référence, qui, quand il est mis à zero détruit ton objet.
Avec Qt, regarde qshareddatapointer
http://qt.developpez.com/doc/latest/...r.html#details
Ou alors si tu utilise boost, il fournie aussi des pointeur intelligent pour cela

[Samildanach]

Déjà merki pour ta réponse rapide, mais je ne vois pas trop comment je dois faire avec le compteur de référence, enfin je ne vois pas quand il doit être incrémenter/décrémenter. Je vois un peu, à chaque fois qu'un objet ayant une référence dessus en a/n'en a plus besoin. Mais c'est que ca fait pas mal de changement lol

Alors pour les smart pointer, j'ai tout lu. Ce qui m'intéresse ce sont donc les explicit smartpointers. Seulement je voudrais être sur de leur fonctionnement :
en gros, je cree une classe AData qui contient les données et ma classe A du coup utilise des getter et setter sur le sharedpointer. Ca ça va :-)
Et donc en fait à chaque fois, qu'un objet va "créer" une référence sur mon objet A (par retour de fonction par exemple donc par l'opérateur =), le compteur va s'incrémenter. Oki mais comment on lui dit qu'une réference est enlevée ? il le comprend tout seul ou pas. J'arrive pas trop à voir ça

[Matthieu Brucher]

Ca marche tout seul, car c'est une classe avec un destructeur, un smart pointer. Et donc dès que l'instance est détruite, il décrémente le compteur de références.

Et oui, ça fait pas mal de changements, mais c'est la seule solution que tu as.

[Samildanach]

Juste j'insiste un peu désolé mais c'est pour bien comprendre
quand tu dis :
"Et donc dès que l'instance est détruite"

tu parles bien de l'instance qui pointe sur l'objet on est d'accord ?

et du coup ça ne marche que sur la destruction de l'instance, ou ça marche aussi sur la portée genre une variable dans un bloc va pointer sur mon objet A, et du coup à la fin du bloc la variable est détruite et donc la réfenrece aussi ?

[yan]

Si tu veut utiliser un smart pointeur de boost, je te conseil d'aller faire un tour sur le forum boost
Sinon, qshareddatapointer peut être une solution( c'est ce qui est utilisé par la pluspart des class Qt pour faire de l'implicite shared
http://qt.developpez.com/doc/latest/...licitly-shared

Tout dépende de ton environnement

[yan]

et du coup ça ne marche que sur la destruction de l'instance, ou ça marche aussi sur la portée genre une variable dans un bloc va pointer sur mon objet A, et du coup à la fin du bloc la variable est détruite et donc la réfenrece aussi ?

normalement oui

[Samildanach]

Ouais je reste sur le shared pointer ça me semble pas mal, explicit sharedpointer même

Oki je vais tester ça je vous remercie de votre précieuse aide

[Matthieu Brucher]

Juste j'insiste un peu désolé mais c'est pour bien comprendre
quand tu dis :
"Et donc dès que l'instance est détruite"

tu parles bien de l'instance qui pointe sur l'objet on est d'accord ?

et du coup ça ne marche que sur la destruction de l'instance, ou ça marche aussi sur la portée genre une variable dans un bloc va pointer sur mon objet A, et du coup à la fin du bloc la variable est détruite et donc la réfenrece aussi ?

Tu as plusieurs instances :
- l'instance de l'objet que tu surveille, I1
- l'instance de l'objet qui encapsule un pointeur intelligent I2
- l'instance du pointeur intelligent encapsulant I1 qui se trouve dans I2, appelé I3.

Naturellement, pour chaque instance I2, tu as un I3 différent, et tu peux aussi avoir une instance I3 sans une instance I2, comme je vais te l'expliquer.

Tu as une instance I2 qui est détruite. Automatiquement, I3 associée est détruite et le compteur de référence est décrémenté. S'il arrive à 0, I1 est détruite.

De manière plus générale, tu as une instance I3 dans une fonction parce que tu veux avoir une référence vers I1. Arrivé à la fin du bloc, automatiquement I3 est détruit, et donc le compteur de I1 est décrémenté et s'il est nul, I1 est détruite.

[Matthieu Brucher]

Ouais je reste sur le shared pointer ça me semble pas mal, explicit sharedpointer même

Oki je vais tester ça je vous remercie de votre précieuse aide

Il me semble que QSharedDataPointer est identique à l'interface près à shared_ptr de Boost, c'est toujours le même principe.

[Samildanach]

Je n'utilise pas boost

Sinon merki de ton explication, très clair en tout cas, j'ai eu beau chercher un tutoriel sur le net à part la doc de Qt y'avait pas grand chose

Mais encore merki à vous

[yan]

Il me semble que QSharedDataPointer est identique à l'interface près à shared_ptr de Boost, c'est toujours le même principe.

Je suis en train de regarder. Ca va beaucoup plus loin
et peut être pas aussi adapté que cela...
Si tu appel une fonction non const, une copie de l'objet sera faite

In a non-const member function of Employee, whenever the d pointer is dereferenced, QSharedDataPointer automatically calls detach() to ensure that the function operates on its own copy of the data

[Matthieu Brucher]

Ah, il y a le principe du COW qui s'applique. Donc QSharedDataPointer est utilisable sans rien en multithread, mais pas shared_ptr

Samildanach> en fait, il regarder du côté du RAII (Resource Acquisition Is Initialization) et en mixant ça avec le comptage de références, tu obtiens les pointeurs intelligents

[Samildanach]

J'ai vu mais ce qui m'intéresse c'est l'explicit shared pointer. Ainsi, tout les pointeurs que je fais sur une instance de A , la modifie, et donc ne la recopie pas. Moi je veux que pour n'importe quel pointeur sur A, les modifications soient répercutées partout, et du coup l'explicit ne fait jamais appele au detach()

[yan]

J'ai vu mais ce qui m'intéresse c'est l'explicit shared pointer. Ainsi, tout les pointeurs que je fais sur une instance de A , la modifie, et donc ne la recopie pas. Moi je veux que pour n'importe quel pointeur sur A, les modifications soient répercutées partout, et du coup l'explicit ne fait jamais appele au detach()

Ha cool. merci de la précision

[Samildanach]

J'ai encore quelques petites questions
Ma classe A doit donc devenir (suivant la doc) la classe AData et donc il faut que je crée une classe qui va s'appeler A du coup et qui contient des getter et des setter qui vont travailler sur le sharedpointer.

Il faut juste des appels simples dans la nouvelles A mais pour les signaux comment ca se passe puisque AData est encapsulee

et aussi lorsque le compteur de reference tombe a 0, seulement AData est supprimé et pas la nouvelle A ?