Salut,
Voila mon pb, j'ai 2 classes A et B comme suit :

Sauf erreur de recopie ca marche. Le(la) deque de la classe B est rempli dans differentes methodes que je n'ai pas ecrites.
 
Dans mon programme, j'efface au fur et a mesure les objets B dont je ne me sers plus, resultat c'est lent (~11s). Si au contraire je les conserve jusqu'a la fin (dans un vector) et qu'alors je les detruis, c'est rapide (~4s).
 
Si je remplace delete *itr par i++ dans le destructeur de B, alors je reviens a une execution rapide. (mais les objets A ne sont plus detruits !)
 
Que dois-je faire ? vider autrement mon(ma) deque ? revoir le destructeur de A ?
Merci pour toute info utile.
 
Pour infos je gere ~100 000 objets B contenant chacun entre 200 000 et 2 objets A. Et les objets B que je souhaite detruire sont parmi les plus gros.
 
KooK

y a un lien entre B et A ?

deque<A*> lst; dans la classe B
 
En fait, j'utilisais une file de pointeurs d'objet B que je vidais au fur et a mesure.
 
Je viens de me rendre compte que si je transfere dans un vecteur 'poubelle' les objets B dont je ne me sers plus et que je vide la poubelle de temps en temps, je gagne en temps d'execution.
 
Donc toujours meme interrogation, pourquoi est-ce plus lent d'effacer le contenu des pointeurs d'une deque (ou file) au fur et a mesure que de le transferer dans un vecteur qu'on efface de temps en temps ?
 
KooK

ais pourquoi t'as des pointeurs ?
 
 
non, c'est pas plus lent, le parcours d'une deque est un poil plus lent qu'un vector, mais ça devrait pas être critique. Ton appli est vraiment bizarre si ton point chaud, c'est la destruction ...
 
#     for(deque<A*>::iterator itr=lst.begin();
#         itr!=direct_occ.end();    itr++)
#     delete *itr;
 
super, mais fait gaffe de bien avoir un constructeur de recopie, affecation
et tu peux également n'appeler .end() qu'une seule fois.

Il faut que je libere la memoire, sinon je sature vite l'ordi.
 
Je viens de refaire mon appli avec uniquement des listes (<list> ). La, je n'ai plus mon pb.
Est-ce que par hasard les deques seraient des tableaux "deguisees" en listes (la memoire n'est liberee qu'a la destruction de la deque) ?
Existe-t-il dans la STL une classe de liste simplement chainee ?
 
Et au cas ou ce n'etait pas clair, mes classes sont un peu plus etoffees que ce qui est ecrit, ce qui justifie l'utilisation des pointeurs ->il me semble qu'il est plus judicieux d'avoir une structure de 200 000 pointeurs que d'objets.
 
Merci quand meme de t'etre penche sur mon pb,
KooK

heink ?
 
le truc auquel tu est peux être confronté, c'est que la deque est implémentée certainement comme une liste de tableau on va dire. Et donc ça risque de pas tout de suite tout désallouer quand tu réduis la taille. Ce que tu pourrais essayer de faire, deque<>::resize.
 
for_each ....
my_deque.resize(0);
 
Mais la list<>, c'est pire. Tu as un bien plus gros surcout en mémoire, le parcours est lent, et ça risque de fagmenter ta mémoire.
 
Tu devrais continuer à chercher du côté des deque<>.
sinon, tu peux toujours essayer
 
my_deque = deque<>()
 
voir carrément
my_deque.swap( deque<>() )

mais attend, je capte pas, à la fin de ta classe B, ta deque membre, elle part à la poubelle ! il devrait y avoir aucun problème à ce moment là, quelque soit le conteneur, ça part à la trappe à la destruction de chaque B.
 
Tu veux pas essayer de faire un programme simple pour reproduire le problème ? tu utilises quoi comme compilateur ?
 
et tu mesures maintenant comment t'aurais moins souffert si t'avais réfléchi un peu et fais
 
template< template<typename T> class C >
class B
{
   typedef C<A*> Storage;
   Storgage lst;
};

Je ne vois pas en quoi ça impliquerait que la mémoire n'est libérée quà la destruction de la deque. Au contraire, il sufit de rediriger les pointeurs (itérateurs) sur les  éléments précédent et suivant, la suppression d'un élément ne fait pas perdre l'itérateur.
 
std::list est une liste simplement chaînée.
Quand à la structure de pointeurs sur les objets, avec les conteneurs standards, ça ne me paraît pas nécessaire.

non, pour la deque, en interne, c'est comme j'ai dit, une sort de liste de tableau.
 
et re-non pour std::list est doublement chainée

 
Cherche "std::list" dans google.fr, et prend le 3ème résultat    

J'ai viré le premier mais j'ai quand même faux sur le second  
Bon ben je crois que je vais m'écraser, là.:whistle:

même pas besoin. Il doit savoir qu'une std::list peut se parcourir à reculons, sans double chainage, ça serait balaise

'fectivement

Ca me rassure de ne pas etre le seul a ne pas comprendre.

Pas du tout, en quoi ca change/resoud le pb ?
Les conteneurs que j'utilise sont tous de la STL, tous ont un iterateur. Et j'utilise un typedef conteneur<A*>.
 
Je precise aussi que les 100 000 objets B que je gere sont dans une liste aussi (une deque au depart, quand c'etait lent).
 
KooK

Peut-être un élément de réponse là :
http://www.codeproject.com/vcpp/st [...] _deque.asp

c'est quoi une 'deque' ?

+1

double-ended queue, l'article que je donne dans le lien ci-dessus l'explique en détail

ha voila, je serai moins ignoarant en me couchant ce soir
 
"Deque Overview :
The deque, like the vector, is also part of the Standard Template Library, the STL. The deque, or "double-ended queue", is very similar to the vector on the surface, and can act as a direct replacement in many implementations. Since it is assumed that the reader already knows how to effectively use the STL vector container, I have provided the table of deque member functions and operators below, solely for comparison and reference."

grillé je suis
merci kan meme el muchacho

Ok, ce lien eclaire ma lanterne, merci beaucoup.
 
Dans mon cas, ce serait le temps de liberation (deallocation) de la deque qui serait (au moins en partie) responsable de mon pb.
 
Je considere mon probleme resolu.
Encore merci a "el muchacho" pour avoir trouve cet article et evidement merci a Nitron.
 
KooK

Kook > le truc c'est que si dès le départ, tu prends 5 minutes pour rendre ta classe template ET faire un typedef, changer la structure interne de ta classe se réduit à ne modifier qu'une seule ligne.
 
tu passerais de B<deque> à B<list> et hop, tout change

ouais ben ça c'est pas normal. Pour une liste, ça revient à libérer N maillons. pour une deque N/M morceaux ... y a un truc de louche, tu ferais bien de l'éclaircir, tu ne pourras pas toujours changer à l'aveuglette de technique comme ça, surtout que la list risque sans doute de te pénaliser dans bien d'autres situations.
 
D'ailleurs est tu bien sur d'avoir remplacer strictement deque par list ?

Dans mon cas, ca n'apporte rien de faire une classe template. Si je n'avais pas modifier le code pour gerer differement la liberation de la memoire (mon vecteur poubelle), changer le conteneur du typedef aurait ete suffisant comme je l'ai fait dernierement.
 
et oui, il n'y a plus de deque ... j'en suis sur grace au typedef
KooK

en attendant, ton explication ne me satisfait pas.  
 
Tu dis que ça te fait perdre du temps de libérer pas à pas, et que la deque mais trois plombes (d'ailleurs à quoi ? à être parcourue pour que tu fasses tes delete ? ou à se désallouée ?) et tu racontes que list est définitivement plus rapide, alors que ça implique une allocation pas à pas, et un parcours bien plus couteux ...

 
à prendre avec des pincettes les chiffres mais on voit bien que list > deque > vector
 

 
à vue d'oeil, le vector prenant 2x moins de mémoire que la list