Bonjour à tous,
 
Je suis devant un os depuis quelques jours et c'est pour cela que j'ouvre ce sujet. J'apprends depuis 2 mois le C++ et j'arrive pas à régler un petit problème de la gestion dynamique de ma mémoire lors d'un renvoi de pointeur d'une fonction.
 
Pour être plus explicite, voici mon code simplifié :
 

Vous aurez donc compris que mon problème vient de la fuite mémoire dû à la création ligne 7 d'un pointeur qui n'a pas de delete ...
 
Je pense que la solution pourrait se trouver dans le destructeur de A mais je n'en suis pas sûr. Donc si quelqu'un pouvait m'orienter sur la solution, cela serait très sympa  
 
Merci d'avance

Bonjour,
 
effectivement, il faut libérer la mémoire après utilisation:
je ferais plutôt comme ceci:

et puis quoi encore ?
tu as testé ton code au moins ?
 
la solution est simple: faire un "delete p" quand il a plus besoin du pointeur.

Utiliser des shared_ptr ou des auto_ptr me parait aussi un peu mieux que de se balader avec des pointeurs le cul à l'air partout

ce serait effectivement la meilleur solution, mais vu la gueule de son "main", j'y crois pas trop...

désolé KangOl, mais j'ai testé mon code et il fonctionne très bien (de plus je pense avoir quelques années d'expérience en C++).
Si on ne peut pas poster pour être utile sans se faire insulter par des pignoufs, il vaut mieux aller aider ailleurs...

Si tu l'avais testé tu verrais 2 grosses fautes (d'étourderie)

Hey, je ne te permet pas de m'insulté !
 
1/ ton code ne compile même pas
2/ "delete A" ?? et puis quoi encore ?
3/ et il se passe quoi si j'appelle deux fois la méthode "MaFonction" ?
4/ c'est quoi ce "main" ?
 

Merci pour vos réponses  
 
J'ai oublié de mentionner que je ne voulais pas utiliser les smart pointeurs ni une autre fonction pour libérer la mémoire pour éviter de surcharger mon main ...

quelques précisions :
 
1/ pour KangOl qui se sent insulté : ce n'est pas moi qui ait écrit "<...du code de merde...>" après mon message  
 
2/ pour sligor : je l'ai testé, mais pas sous la forme simplifiée sous laquelle j'ai répondu (j'ai de façon classique un fichier .cpp, un .h, etc).  
Il fonctionne très bien sous C++Builder, sans augmentation de mémoire allouée à chaque appel.
 
Je l'ai rédigé ainsi dans ma réponse pour coller à la mise en forme de infeneon. Il n'est donc pas impossible qu'il y ait des fautes d'étourderie (merci de me signaler lesquelles)
 
 

 
tellement mieux de se tirer une balle dans le pied que de faire #include <auto_ptr> ...

J'ai précisé que j'apprenais le C++ et je voulais savoir si c'était possible de ne pas utiliser un bazooka (c'est à dire les smarts pointeurs) pour détruire un insecte ... Problème auquel il n'y a donc pas de solution apparemment  

bah si: delete monobjet
 
Mais les smarts pointeurs ne sont pas des bazookas et sont totalement adaptés à ton problème.
Au contraire, quand on apprend il vaut mieux d'abord les utiliser sur des problèmes simples.

ok je vais me pencher sur les smarts pointeurs.
 
Par contre, un delete monobjet, ne libérera pas la mémoire occupée quand j'ai fait A * monpointeur = new A();
 
Donc la meilleure solution est de parthaon même si elle ne me convient qu'à moitié vu qu'elle surcharge mon main

non mais oh v_v
 

 
Arretons le touchage de nouilles merci.

Le problème, selon moi est que tu crées 2 pointeurs (avec le A * monpointeur = new A(); et le A * p; ) et que tu n'en delete qu'un non ?
 
Le premier n'a donc jamais eu de delete.

non
Il n'y en a qu'un seul.
un new et un delete.

 
comem l'a dit Kangol à chaque new son delete.
Déclarer une variable de type pointeur ne veut pas dire que tu as allouée de la mémoire

Oh oui pardon. C'est le matin  
 
Mais par contre, pour être propre, c'est l'obet qui fait le new qui doit faire le delete (enfin c'est ce que j'ai appris ...)
 
Donc pas d'autre moyen que d'encombrer mon main d'une fonction qui libère la mémoire ...

utiliser des smart_pointeur ...
 
et arrete avec cette histoire d'encombrer le main, ca veut rien dire.
T'as le droit de fair eplusieurs fichiers aussi le Mo coute pas cher

Sauf quand tu fais de l'embarquer .......

Non, ça c'est quand l'objet qui fait le new possède l'objet.  
Or ici l'objet qui fait le new ne possède plus référence de l'objet, il "le donne", donc ce n'est pas à lui de le détruire, il délègue la responsabilité.
C'est pour cela qu'on conseille les smart pointeurs car il permettent de gérer cette délégation de façon plus sûre avec moins de risque d'oubli.

bha tu fais du C alors

De nos jours les compilateurs optimisent très bien le code, je ne suis pas sûr que la différence soit énorme.

peut etre, j'ai jamais fait d'embarqué

L'embarquer évolue en ce moment (des processeurs utilisant le cache sont sur le marché par exemple ce qui est un assez grand pas quand on voit qu'Arianne tourne avec des processeurs d'il y a 20 ans ...)
 
Donc le C ne va plus suffire même pour de l'embarquer dans les années à venir.
 
Sinon, pour en revenir au ch'tit problème, merci sligor pour cet éclaircissement  
 
Je vais essayer de me débrouiller avec tout ça même si je reste un peu sur ma faim ...
 
Merci.
 
Edit : juste une remarque :

C'est un peu contradictoire non ?

non.

je parlais du Mo de source
 
et je fais du C++ pour l'embarqué avec des projets de plusieurs Kilo-fichiers ... ça pose pas d epb
 
Anyway, si tu fais de l'embarqué,le concept même de new/delete est à proscrire au profit justement de pointeur managé comme les smart_pointer