std::string et fuite de mémoire

Version imprimable

Bonjour,

Je programme avec Visual Studio Express 2005.

J'ai installé Visual Leak Detector, un detecteur de fuite de mémoire... efficace !

Du coup j'ai pu corriger quelques fuites, mais une derniere me laisse perplexe.

J'ai une classe cListe qui peut contenir des elements.

On ajoute un élément avec :
Code:

1 2 3 4 5 6 7 8 int m_valeur; std::string m_texte; void ajouterElement(int valeur, std::string texte) { m_valeur = valeur; m_texte = texte; }
Et j'ai une fuite sur certains éléments créés, indiquée sur la ligne

m_texte = texte;

J'ai donc pensé que je ne libérais pas la mémoire de certaines string... pour vérifier, j'ai codé en dur :
Code:

1 2 3 4 5 6 pListe->ajouterElement(0, "test 1"); pListe->ajouterElement(0, "test 2"); pListe->ajouterElement(0, "test 33333333333333333333"); pListe->ajouterElement(0, "test 4"); pListe->ajouterElement(0, "test 5");
Et là, j'ai une fuite de mémoire systématique dans l'éxecution de :

pListe->ajouterElement(0, "test 33333333333333333333");

Comme si la longueur de la chaine posait probleme....

Je m'y prend mal avec les std::string ?

Merci !

08/06/2007, 11h52
Mat007

Salut,

La fuite est vraisemblablement en amont, sans doute que tu ajoutes un élément dans la liste mais tu ne le détruits jamais.
Du coup oui, techniquement ce qui fuit c'est le tampon interne de std::string, mais en fait il faut regarder l'objet qui possède la std::string.

Une autre possibilité est que VLD hallucine, mais je l'ai un peu utilisé et il a l'air assez fiable quand même...

MAT.
08/06/2007, 11h55
buzzkaido

Citation:

La fuite est vraisemblablement en amont, sans doute que tu ajoutes un élément dans la liste mais tu ne le détruits jamais.

Je ne crois franchement pas, car je ne detruit pas les elements de la liste "à la main"

Ils sont tous détruits par une boucle dans le destructeur de la liste.

Et les seuls elements sur lesquels il y a fuite de mémoire ce sont les éléments avec une chaine "un peu plus longue"

Donc je comprend pas vraiment... et j'ai un peu de mal à mettre en doute les std::string...

Et si tu passais tes paramètres par référence??

Code:

1
2
3
4
5
void ajouterElement(const int & valeur, const std::string & texte)
{
    m_valeur = valeur;
    m_texte = texte;
}

08/06/2007, 12h24
fredczt

T'as essayer de faire un petit programme qui ne fait que créer cette chaine longue. Puis tu verifies si fuite.
Puis un petit prog qui cré et ajoute cette longue chaine à la liste et tu verifies si fuite...
Ca te donnera une idée de la provenance du bug. std::string ou plus en amont, genre ta list qui est pas bien initialisée...
08/06/2007, 12h42
buzzkaido

Ben je vois pas trop pourquoi ça changerait quelque chose...

A moins qu'il y ait une façon de proceder particuliere avec les string ?
08/06/2007, 12h56
buzzkaido

Euh, le message d'avant c'etait pour poukill...

fredwilli : oui, effectivement, j'ai pas encore fais de test plus "decomposé" je testerais ce soir...

Je voualis surtout savoir s'il n'y a pas un probleme connu autour de ça...
08/06/2007, 15h04
Aurelien.Regat-Barrel

les string de VC++ de font un malloc qu'a partir d'une certaine longueur (15 je crois). Mais a priori y'a pas de fuite, c'est juste ton outil qui déconne.
http://c.developpez.com/faq/cpp/?pag...MES_STL_fuites
tu peux checker avec le mécanisme de la CRT pour etre sur.
http://msdn2.microsoft.com/en-us/lib...cf(VS.80).aspx
08/06/2007, 15h11
buzzkaido

Merci pour l'info !

Mais Visual Leak Detector est, je crois, basé sur les mécanismes de la CRT...

Par contre, si il déconne, ça ne m'arrange pas.... car pour le moment je lui fait une confiance quasi-aveugle...

Sinon, y-a-t-il d'autres outils du même type, faciles à installer et à utiliser avec Visual Studio Express ?

(ce que j'aime bien avec VLD, c'est qu'il y a juste à inserer les en-tete, il s'occupe de tout...)
08/06/2007, 15h12
poukill

Valgrind ? ;)
08/06/2007, 15h22
Aurelien.Regat-Barrel

je ne crois pas que valgrind fonctionne sous windows.

De ce que j'en ai entendu, a peu pres tous les outils de detection de fuites émettent de fausses alertes, y compris ceux qui se vendent assez cher (genre Purify). Les strings sont un cas typiques, parce qu'elles sont souvent gérées de maniere assez complexes pour optimiser les perfs.

S'il ne t'indique qu'une seule fuite au niveau de ta std::string, je pense que tu peux ignorer...
08/06/2007, 15h40
buzzkaido

Ok, merci pour toutes ces infos.
11/06/2007, 10h57
loufoque

Tu appelles bien delete sur chacun des noeuds de ta liste ?
11/06/2007, 11h01
buzzkaido

Oui oui, je fais bien un delete à chaque fois.

D'ailleurs, il n'y a qu'avec des chaines "longues" que j'ai une fuite. Si je met que des courtes, pas de fuite...

CQFD...
11/06/2007, 15h11
loufoque

C'est peut-être tout simplement ton implémentation de std::string qui ne libère pas la mémoire afin de pouvoir la réutiliser ultérieurement.
12/06/2007, 15h22
fredczt

J'ai déjà eu des fuites mémoires réccurentes dans std::string avec purify. (sous Solaris). Je confirme l'efficacité relative de ces produits.:?

Juste une question, est-ce que ton progamme plante?
12/06/2007, 15h28
buzzkaido

Non, mon programme ne plante pas...

A priori, je pencherais plutot pour un truc du genre :

Citation:

C'est peut-être tout simplement ton implémentation de std::string qui ne libère pas la mémoire afin de pouvoir la réutiliser ultérieurement.

Même si ça m'étonne que la mémoire ne soit pas libérée après la fin de l'éxecution du programme....

Et que je n'ai des fuites que sur des chaines de plus d'une dizaine de caractères...
12/06/2007, 16h37
loufoque

Citation:

Et que je n'ai des fuites que sur des chaines de plus d'une dizaine de caractères...

Ton implémentation fait peut-être aussi de la Small String Optimization, c'est à dire que l'objet std::string contient un tableau d'une taille fixe N où est mise la chaîne si elle est suffisamment petite, et que sinon std::string utilise de l'allocation dynamique.

Citation:

Même si ça m'étonne que la mémoire ne soit pas libérée après la fin de l'éxecution du programme....

Quand un processus se termine la mémoire qu'il utilisait est forcément récupérée par l'OS. Il ne sert donc à rien de libérer la mémoire à la fin du programme, si ce n'est à perdre du temps.
12/06/2007, 16h38
buzzkaido

Ok, ceci explique donc surement cela !

Merci !

juste une question ^^
Code:

1 2 3 4 5 6 7 #include <string> int main() { std::string abc = "abcdefghijklmnopqrstuvwxyz"; return 0 }
Il te fait une fuite de mémoire là aussi?