Reprise du message précédent :

 
Fais comme tu veux...Ce n est pas un probleme...mais moi j aimerais tout de meme savoir comment sa marche !!! Si tu ne veux pas me repondre, libre a toi !!! Mais moi, quand je conduit une voiture, j aime bien savoir comment le moteur marche.... D ailleurs je savais comment marchés les différents éléments d une voiture avant de savoir conduire....
Maintenant, si vous me dites que ce n est pas une question de C++, alors je vais me renseigner dans les directions indiquées par bjone...
Toutefois, je modifie ma question pour vous plaire... Dans quels cas creer des variables dynamiques plutot qu automatique ? Ca c est tout de meme en partie du C++ (meme si c est valable dans tous les languages) car je vais etre "confronte" a ce probleme par la suite... Alors si je peux eviter toute erreur.... Je crois avoir compris que l on créé des variables dynamiques quand  on créé et supprime regulierement des elements d une classe par exemple...Mais pour quoi d autre ? Y a t il un gain de vitesse en utilisant des variables dynamiques ou est ce que cela n a rien a voir ?

le truc c'est que tu ne sais pas la conduire la voiture, le cas présent. tu ne maitrise pas l'aspect fonctionnel des variables automatiques/dynamiques, qu'est-ce que tu veux aller voir plus bas ? et me dit pas le contraire.
 

t'as toujours pas pris en compte ce qu'on te dit depuis le début.

Ce n'est pas la vitesse qui doit dicter ton choix, mais la portée des variables, comme Taz n'a cessé de le répéter!

En plus simple : n'utilise pas de variables dynamiques si tu peux faire autrement. Les variables dynamiques ca sert a si tu décides de créer des objets pendant l'execution.

 
Ok .... C est un peu ca que j attendais comme reponse Merci.... En fait, je pense que je devrais en utilise car je compte utiliser de objets (modele de particules) que j'ajouterais ou retirais au cours de l execution
 
En effet...je ne sais pas conduire la voiture C++, ce qui ne m empeche pas forcement de comprendre ce que les praticants de cette voiture peuvent me dire d une facon simple et ainsi eviter de faire les memes erreurs.... D autre part, comprendre le fonctionnement d une voiture n a pas grand chose a voir avec son utilisation et pas besoin de conduire pour comprendre (meme si souvent c est plus simple)....

sylvaing >> tu as lu mon post d'exemple ?

Oui oui... Je l ai vu...un peu tardivement mais je l ai vu.... C est comme ca que j ai vu que ca correspondait bien a ce que je voulais faire Mais j aurais voulu avoir plus d exemple et de cas ou il faut utiliser un type de declaration plutot qu un autre et pourquoi le faire.... Je me doutais que c etait utilisé pour des objet que l on cré et supprime comme dans ton exemple...mais j aimerais bien aussi savoir pourquoi c est utile...
 
Gracias pour les reponses

c'est pas compliqué à comprendre.
 
si tu fais:
 
class Patate
{
public:
    int truc, machin, bidule....
};
 
main()
{
   fonction1();
}
 
fonction1()
{
  Patate petitepatate;
}
 
"petitepatate" n'existera plus à la fin de fonction1.
de retour dans le "main" d'une part, tu n'as pas moyen d'atteindre quelque chose qui viens de "fonction1", et d'autres part si tu arriverais à le faire (j'anticipte le truc dégueulasse que je vais expliquer à la fin), tu atteinderai un truc qui est indéfini, logiquement inexistant (mais pourtant touchable).
 
pour "créer" quelque chose qui survit autant que tu veux, il faut le créer dynamiquement avec un new (et se démerder pour ne pas le perdre).
 
donc par exemple:
 
Patate *fonction2()
{
    Patate *ptte=new Patate; // cette Patate vivra jusqu'a ce que on la "delete"
 
    ptte->OnLaLave();
 
    return ptte;
}
 
main()
{
  Patate *patatevivante;
 
  patatevivante=fonction2();
 
   for( .... on boucle .... par exemple sur des pressions de touche )
   {
      si touche 'P':
         patatevivante->OnLaPèle();
      si touche 'C'  
         patatevivante->OnLaCuit();        
      si touche 'B'
         // pouBelle
         delete patatevivante;
   }
}
 
Si tu prends les 2 pointeurs, ils sont temporaires, local à chaque fonction, le pointeur "ptte" est local à "fonction2", "lui-même" il saute à la fin de la fonction, mais pas l'objet "Patate" qu'il pointait par son doigt vengeur.
 
Et lorsque "fonction2" retourne elle redonne l'adresse de l'objet Patate crée au "main" qui la maintiendra via sont pointeur "patatevivante".
 
et lorsque tu appuies sur B là l'objet Patate est réllement supprimmé entre "", mais attention le pointeur pointe toujours sur l'ancien emplacement mémoire de la Patate.  
 
Même si la Patate n'a plus cours, on peut toujours la pointer du doigt.
 
tu peux donc faire l'horrible et punissable erreur (par une flagellation en place publique) de bricoler le cadavre de la Patate en tentant de la triturer. (la nécrophilie c'est le mal)
 
donc la chose à ne pas faire ce serait de se retrouver avec ça:
 
si touche B:
    delete patatevivante;
    patatevivante->longueur=patatevivante->hauteur*16/9;  
    //(pour mettre la patate au format cinémascope)
 
et là si tu le fais, tu verras tout une équipe de rugby se ruer sur toi  pour te plaquer au sol afin de te punir.
 
et prends garde: plus l'équipe mets du temps à venir, plus forte sera la pression.
 
-donc- pour ne pas faire ça, on pourrait changer main ou tout autre fonction (qui contiendrait la boucle de réaction aux pression de touches, on n'est pas limité à main) pour avoir quelque chose comme ça:
 
main()
{
  Patate *patatevivante;
 
  patatevivante=fonction2();
 
   while( patatevivante )  // à traduire par "tantque patatevivante est non nulle, et quelque chose différent de 0 est non nul"
   {
      si touche 'P':
         patatevivante->OnLaPèle();
 
      si touche 'C'  
         patatevivante->OnLaCuit();        
 
      si touche 'B'
         // pouBelle
         delete patatevivante;
         patatevivante=NULL; // ou équivalent patatevivante=0;          
   }
}
 
là on sait que le pointeur "patatevivante" en étant initialisé à une valeur (donc adresse en fait) connue et ayant comme convention un pointeur qui pointe sur rien (bien que c'est faux il pointe sur l'adresse 0000000), on peut éviter de triturer cette pauvre Patate quit pourrit dans la poubelle (ce qui n'est pas très hygiénique tu m'accorderas).
 
donc:
 
tu veux un truc qui vive "tant que tu le décides":
généralement ça fera quelque chose comme:
 
Patate *doigt_sur_patate=new Patate;
 
tu veux benner la patate:
 
delete un_doigt_sur_une_patate;  
 
sachant que "un_doigt_sur_une_patate" est en principe un pointeur sur Patate, donc un "Patate *" quelquechose;
 
ce n'est pas forcément le même pointeur...
tu peux avoir plusieurs pointeur qui pointent sur le même objet.
 
donc maintenir à la création ta Patate dans "Doigt1", genre:
 
Patate *Doigt1=new Patate;
... du code, des appels de fonctions
... du code, des appels de fonctions
Patate *Doigt2;
... du code, appels...
... du code, appels...
Doigt2=Doigt1;
... du code...
delete Doigt2;
 
là notre Patate originalle sera bien supprimmée.
 
MAIS: autre cas de flagellation, pas de multiples "delete".
pour chaque "new", son seul et unique "delete".
 
Donc PAS de:
 
delete Doigt2;
delete Doigt1;
 
tout en sachant Doigt2 et Doigt1 doigtent la même Patate.
 
à toi d'être cohérent dans ta tête.
sinon c'est la peine de mort pour ton programme.
 
et symétriquement, chose aussi qui te fera brûler en enfer:
(c'était le truc dégueulasse dont je parlais au début)
 
Patate *fonction3_pas_belle()
{
   Patate patate_locale;
 
   ....
   .... du code
 
   return &patate_locale;  
 
  // et oui patate_locale où qu'elle soit, a une adresse,  
  // les robots chinois du FBI peuvent donc la traquer  
  // et la pointer du doigt.
}
 
main()
{
   Patate *patate_pourrie;
 
   patate_pourrie=fonction3_pas_belle();
 
   ...
   ...  
   ...
}
 
voilà donc là, la "patate_locale" de "fonction3_pas_belle" étant locale à la fonction, passera à la benne toute seule en sortant de "fonction3_pas_belle", qui retournera quand même l'adresse mémoire de la défunte et contagieuse Patate.  
 
-----
 
voilà on a fait le tour, je ne vois pas comment t'expliquer mieux ( à 2h du matin ) le cycle de naissance et de mort d'un objet qu'il soit simple/élémentaire ou compliqué (dans le sens composé par d'autres objets élémentaires ou eux-même compliqués).
 
après si tu assimilé ça, on pourra par exemple passer aux cours d'éducation sexuelle et comment les objets se reproduisent entre eux (là c'est plus C++, alors que le genre de truc que je t'ai expliqué là ça reste "universel", et quelque chose à maitriser dans ta tête).
 
pour bien comprendre, relis le tout plusieures fois, et vois comment les  choses se complètent, après cela tu seras un padawan de la manipulation objets à travers des pointeurs.

oh purée

bof ... pas besoin d'allocation dynamique

bjone -> Muchas gracias .... Je crois tout de meme que je comprennais bien ce que tu as ecris...mais bon...c est toujours bon d entendre ca de la bouche de plusieurs personnes ... Alors je suis pret pour ta deuxieme lecon

j'ai essayé de faire un truc ras la moquette pour que ce soit compréhensible

 
2h du soir powa

C'est beau. C'est tellement beau.
 
Je n'ai pas l'impression que tu aies appris sur le tas.

bien joué

non.

c'est quoi ton message d'erreur juste pour voir ...
 
et j'ai aucune idée de ce qu'est VirtualAlloc ... un bon malloc doit être capable de faire de l'allocation copy_on_write si nécessaire.

déjà commence par vérifier le retour de malloc. ou utilise new et catch les bad_alloc. Tout ce que tu dis, c'est bien connu, c'est toujours le marteau qui est cassé.

c'te déterrage de topic
 
regarde la mémoire consommée par ton programme dans le gestionnaire des taches, sous Windows un process Win32 n'a droit qu'a 2Go d'espace de donnée.
 
donc si tu t'as une fuite quelque part, un malloc doit nuller à un moment

PUTAIN tu nous saoule avec tes heap overflow !
c'est TON code le problème, tu dois balader des saloperies de pointeurs là ou il faut pas, faire une double free() ou un truc du genre.

complètement

bin tu dois avoir des allocations/déallocations pas symétriques je suppose. où des doubles déallocations.
post ton code.