Discussion :

[Nykoo]

Bonjour, quand on stocke des objets dans des conteneurs quelconques tels que QList, est-ce que ça apporte quoi que ce soit des mettre des pointeurs à la place d'objets?

J'ai vu (dans la doc il me semble) que les conteneurs font très bien leur travail stockent eux même des pointeurs sur les objets stockés. Donc inutile de stocker des pointeurs au lieu d'objets.

Je voudrais juste avoir confirmation.

Autre question: le destructeur du conteneur appelle le destructeur de l'objet stocké?

[nouknouk]

salut,

la grosse différence entre stocker les objets et stocker leurs pointeurs est que lorsque tu stockes des objets, c'est une copie de l'objet qui est faite.

Partant de là, tout dépend de tes besoins, mais il vaut mieux limiter les copies d'objets au maximum lorsque ceux-ci sont 'imposants' et que ce n'est pas indispensable.
Par exemple, faire une QList sur des instances d'objets contenant un buffer de plusieurs dizaine de ko risque de rapidement alourdir le programme ; à contrario, faire une QList de pointeurs sur des 'int' n'a quasiment aucun sens.

Concernant le partage de ressources, il existe effectivement des classes qui sont malignes et qui peuvent partager le même espace mémoire quand elles contiennent exactement les même données. Elles sont alors capables de se détacher l'une de l'autre (et donc d'avoir chacune leur copie des données) quand c'est nécessaire, c'est à dire quand un accès en écriture est fait dans l'un des objets qui pointe vers l'espace de données commun.

On appelle ça le 'copy on write', et différentes classes du framework Qt le gèrent automatiquement (entres autres QByteArray et QString, si ma mémoire est bonne). Pour savoir quelles classes le gèrent et quelles autres ne le gèrent pas, il faut aller voir au cas par cas dans la doc Qt.

En espérant avoir répondu à ta question...

EDIT: le 'copy on write' est aussi appelé 'implicit sharing' dans la doc de Qt et le lien ci-avant te donnera la liste des classes qui le supportent (à savoir ... une bonne patatée dans Qt4 )

[Nykoo]

Merci d'avoir pris le temps de me répondre aussi clairement. Malheureusement je connais bien ce que tu as expliqué, j'ai du mal poser la question.

En fait, je voulais savoir si en interne, les conteneurs de Qt stokaient les objets de type T (ex si on a crée une liste QList<T>) ou seulement des pointeurs T* de ces objets, ce qui parraît plus logique.

En fait en relisant mieux la doc la réponse:

Internally, QList<T> is represented as an array of pointers to items. (Exceptionally, if T is itself a pointer type or a basic type that is no larger than a pointer, or if T is one of Qt's shared classes, then QList<T> stores the items directly in the pointer array.)

Donc inutile de lui filer des pointeurs, autant lui donner des objets dont il prendra seulement les pointeurs.
En plus ça répond à une autre question que je me posais: si on lui file des pointeurs il stocke directement les pointeurs. Et si on lui donne des objet "shared" il stocke aussi les pointeurs.

Par contre faut que je fasse gaffe au cas où je lui donne un objet dont la porté est limitée et dont il garde un pointeur.

Ma 2ème question: Le destructeur du conteneur appelle le destructeur de l'objet stocké?

[yan]

Euh... je ne comprend pas trop ta question, mais si tu as un QList<T>,
Ta liste utilisera bien des pointeur, c'est son fonctionnement interne.
Mais quand tu fait

Code :

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

1
2
3
4
 
int i =1;
QList<int> l;
l.append(i);

append ajout la valeur i en créant une copie.

[Nykoo]

Oui c'est bien ça merci, et pour ma 2ème question?

[yan]

Oui c'est bien ça merci, et pour ma 2ème question?

Ce que je voulais dire, que tu utilise des pointeur ou non, ca ne change que la gestion en interne de ta QList.
Je ne comprend pas ta question..
Peut tu faire un morceau de code pour aider à expliquer ta question???

[Nykoo]

Ah non je parle de la 2ème question pas de mon 2ème post

2ème question: le destructeur de QList appelle-t-il le destructeur des objets stockés?

[yan]

Ah non je parle de la 2ème question pas de mon 2ème post

2ème question: le destructeur de QList appelle-t-il le destructeur des objets stockés?

Si ce n'est pas un pointeur oui

[nouknouk]

Oui c'est bien ça merci, et pour ma 2ème question?

Non, te remarque suivante montre qu'on ne s'est pas bien compris.

Par contre faut que je fasse gaffe au cas où je lui donne un objet dont la porté est limitée et dont il garde un pointeur.

On n'est pas d'accord sur ce point : ok, dans la tambouille interne des conteneurs, c'est stocké sous forme de pointeurs.

Mais la tambouille interne reste la tambouille interne. Ce qui t'intéresse, toi c'est le comportement du point de vue 'utilisateur de la classe'. Et là, c'est l'utilisation suivante:

Lorsque tu as une liste d'objets à laquelle tu ajoutes un objet, une copie de l'objet que tu as passé en paramètre est faite. En d'autres termes, en interne, bien que le stockage se fasse par pointeurs, la liste ne stocke pas le pointeur de l'objet que tu lui as passé en paramètre, mais sa copie.

Ainsi, ceci est valable:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
QList<int> list;
 
void foo() {
    int i =123;
    list.append(i);
    // une copie en interne de i a été faite (appelons la 'z').
    // list en interne stocke le pointeur vers 'z'
}
// fin de fonction, la variable i est détruite.
 
void main(int argc, char** argv) {
    foo();
    int j = list.get(0); // retourne une copie de 'z'
}
// fin de programme.
// list est détruite et 'z' est détruit avec.

En d'autres termes, j vaudra bien 123, alors même que i a déjà été détruite depuis que le programme est sorti de la fonction 'foo', ce qui prouve qu'une copie de i a été faite lors de ton 'append' à la liste.

Pour la deuxième question, on a bien les deux cas:

- QList<FooObject> appelle bien le destructeur de chaque objet.
- QList<FooObject*> n'appelle pas le destructeur de ce vers quoi pointe FooObject*, il ne détruit que le pointeur.

C'est logique : pour un type de template donné T, on a:

- si T = MonObjet, un delete &T (donc delete Monobjet*) sera fait dans le QList::remove, donc l'instance de T sera supprimée.

- si T = MonObjet*, un delete &T (donc delete Monobjet**) sera fait dans le QList::remove, donc l'instance du pointeur de MonObjet sera supprimée, pas l'instance de T.

Pour t'embrouiller encore un peu plus (), il existait une fonction dans Qt3 qui faisait ce que tu voulais, à savoir supprimer l'instance correspondant à un pointeur, dans le cas d'une collection de pointeurs : setautoDelete(). Mais elle n'existe plus avec Qt4.x, probablement car les conteneurs d'objets et les conteneurs de pointeurs d'objets ont été fusionnés en une seule classe avec le passage de Qt 3.x à Qt 4.x.

En espérant avoir été plus clair (ou pas )

[Nykoo]

Ok un grand merci à vous deux