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

**Pfeffer** · 02/12/2006, 18h56

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 :

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

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

**millie** · 02/12/2006, 19h12

Code :

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

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.

**Pfeffer** · 02/12/2006, 19h16

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!

**millie** · 02/12/2006, 19h21

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 :

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

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.

**Pfeffer** · 02/12/2006, 19h26

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.

**millie** · 02/12/2006, 19h27

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.

**Pfeffer** · 02/12/2006, 19h34

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.

**millie** · 02/12/2006, 19h37

. 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...

**Pfeffer** · 02/12/2006, 19h40

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!

**Médinoc** · 02/12/2006, 20h32

Vérifie que tu n'as pas de truc sournois de ce style:
http://en.wikipedia.org/wiki/Memory_...an.27s_example

**loufoque** · 02/12/2006, 21h01

Pourquoi t'utilises tout simplement pas du RAII ?

**Matthieu Brucher** · 02/12/2006, 21h01

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.

**koala01** · 03/12/2006, 13h15

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 :

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

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 :

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

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 :

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
 
class MonObj
{
    public:
        MonObj* Create();
        MonObj();
        ~MonObj();
        void Mafonct();
        ...
    protected:
        MonObj *Suivant;
}
 
MonObj::MonObj():Suivant(NULL)
{
 
}

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
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 :

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

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

**swirtel** · 03/12/2006, 17h00

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 ?

**Pfeffer** · 06/12/2006, 16h00

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.

**Matthieu Brucher** · 06/12/2006, 16h03

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

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

C++

Discussions similaires

Partager

Partager