[C++] allocation dynamique de la mémoire trop importante

Version imprimable

02/12/2006, 18h56
Pfeffer

[C++] allocation dynamique de la mémoire trop importante
Bonjour,

J'ai une application qui fait une importante opération et qui prend les 100% de l'UC.

Durant cette opération la charge dédiée dans le gestionnaire de tâche augmente sans cesse jusqu'à atteindre les 500Mo. Enorme...

J'ai fait attention à ce que chaque allocation de mémoire avec l'opérateur new soit suivi d'un delete. Mais rien n'y fait je reste à 500Mo. Ce qui me fait peur c'est qu'à la fin de mon opération je reste à 500Mo. Et la aussi je n'arrive pas à faire redescendre la valeur. Il faut que je kill le process pour revenir à la normale.

Dans le code je fais à chaque fois ceci:
Code:

1 2 3 4 5 6 MonObj * obj = new MonObj() /*fait appel au destructeur de mon objet qui lui même delete les objets du style TStringList ... */ delete obj ; obj = NULL;
Comment faire pour améliorer l'allocation dynamique de la mémoire ?
Merci

Code:

1 2 3 4 5 MonObj * obj = new MonObj() /*fait appel au destructeur de mon objet qui lui même delete les objets du style TStringList ... */ delete MonObj; MonObj = NULL;
Ca compile ça ???? Car MonObj est une classe (et pas une instance) et tu fais MonObj = NULL et delete MonObj.

02/12/2006, 19h16
Pfeffer

Désolé je me suis trompé en écrivant! Je fais biensur un delete sur obj et je remet obj à NULL.

Je suis un peu fatigué moi LOL!
02/12/2006, 19h21
millie
Ca ne suffit pas à faire prendre autant de mémoire.

As-tu des allocations qui sont écrites dans une boucle ?

Car a priori, c'est plus le comportement d'un programme du style :
Code:

1 2 3 4 5 while(true) obj = new Objet(); delete obj;
Normalement, il est possible de détecter ce genre de problème (soit en regardant ton code de plus près), soit avec un utilitaire de détection de fuite mémoire du style : valgrind.

EDIT : mais si ton code n'est pas très gros, ça va peut être plus vite de voir ça à la main.
02/12/2006, 19h26
Pfeffer

J'ai en effet dans mon code quelques endroits ou je boucle et je fais des allocations dynamiques. Mais j'ai bien regardé, a chaque sortie de boucle je delete.
02/12/2006, 19h27
millie

Citation:

Envoyé par Pfeffer

J'ai en effet dans mon code quelques endroits ou je boucle et je fais des allocations dynamiques. Mais j'ai bien regardé, a chaque sortie de boucle je delete.

Tu es sûr de sortir de ta boucle. Tu vois que dans l'exemple que je t'ai montré, il y a une fois écrit new pour une fois écrit delete, pourtant, il y a une infinité de new qui sera fait à l'exécution.
02/12/2006, 19h34
Pfeffer

Oui je suis certain que je sors de ma boucle vu que l'application me renvoie un résultat suite à cette opération. Et puis je peux recommencer une nouvelle fois mais la je fais tout sauter LOL vu que la mémoire n'est pas revenue à son état d'origine.
02/12/2006, 19h37
millie

Citation:

. Il faut que je kill le process pour revenir à la normale.

En tout cas, ça ça veut dire que ton programme ne s'arrête pas de lui même et donc que tu dois avoir une boucle infinie...
02/12/2006, 19h40
Pfeffer

Non je me suis mal exprimé, lorsque je quitte l'application et ceux normalement (sans passer par le gestionnaire de tâche), tout redevient normal!
02/12/2006, 20h32
Médinoc

Vérifie que tu n'as pas de truc sournois de ce style:
http://en.wikipedia.org/wiki/Memory_...an.27s_example
02/12/2006, 21h01
loufoque

Pourquoi t'utilises tout simplement pas du RAII ?
02/12/2006, 21h01
Matthieu Brucher

Citation:

Envoyé par Pfeffer

Non je me suis mal exprimé, lorsque je quitte l'application et ceux normalement (sans passer par le gestionnaire de tâche), tout redevient normal!

Normal, l'OS libère la mémoire automatiquement.
Sinon, tu peux utiliser les pointeurs intelligents au cas où.
Les conteneurs de la STL ne libèrent pas non plus la mémoire quand on fait un clear.

Salut,

Je serais un peu de l'avis de millie...

Si tu fais une allocation dynamique dans une boucle, il faut que le delete correspondant se trouve aussi dans une boucle équivalente... le tout, en veillant toujours à ne pas refaire une allocation sur un pointeur qui serait perdu du fait de l'allocation...

Deux "cas d'école":

Code:

1
2
3
4
5
6
7
8
9
10
11
 
MonObj *obj;
for(int i=0;i<10;i++)
{
    obj=new MonObj();
    // nok: on perd toute référence à l'objet alloué lors du passage précédent
    // dans la boucle
    ...
}
delete obj;//ne libérera que le dernier obj alloué... et on n'a aucune possibilité
           //récupérer les 9 premiers

Code:

1
2
3
4
5
6
7
8
9
10
 
for( int i=0;i<10;i++)
{
    MonObj *obj;
    obj=new MonObj();
    ...
    delete obj;
    //ok: l'objet est libéré avant d'essayer d'allouer le suivant lors du passage
    //suivant dans la boucle
}

Mais ca peut etre plus vicieux que cela...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
class MonObj
{
    public:
        MonObj* Create();
        MonObj();
        ~MonObj();
        void Mafonct();
        ...
    protected:
        MonObj *Suivant;
}
 
MonObj::MonObj():Suivant(NULL)
{
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
MonObj* MonObj::Create(MonObj* actuel)
{
    MonObj* nouveau=new MonObj();
    actuel->Suivant=nouveau;
    return nouveau;
}
void MonObj::Mafonct()
{
    MonObj* recup;
    recup=Create();
    this->Suivant=recup;
    for(int i=0;i<10;i++)
    {
        recup=Create(recup);
    }
    //traitement
    delete Suivant;
}

pourrait tres bien fonctionner... pour autant (et à la condition sine qua non) que l'implémentation du destructueur soit

Code:

1
2
3
4
5
 
MonObj::MonOb()
{
    delete Suivant;
}

03/12/2006, 17h00
swirtel

Pourquoi n'emplois-tu pas des pointeurs intelligents de la STL ( std::auto_ptr ) ?
Tu peux aussi employer des containers stl comme vector ou list ( voir ce dont tu as réellement besoin ) et utiliser des pointeurs intelligents de la Boost ( boost::shared_ptr ), afin de pouvoir les mettres dans les containers ?
06/12/2006, 16h00
Pfeffer

J'ai regardé un peu les vector et les container et j'ai encore une petite question.

Lorsque j'alloue un TStringList et que je fais un delete derrière. Est ce que je supprime tout le container ou seulement la dernière ligne de ma liste ?

Parce que dans mon cas, j'utilise beaucoup les TStringList pour stocker des chaines de caractères. Mais je peux mettre 5000 lignes par exemple dans ma liste.

Sinon merci à tous je vais essayer de résoudre cette fuite mémoire avec la classe vector.
06/12/2006, 16h03
Matthieu Brucher

Si tu détruis ton conteneur, tout est désalloué.