Hola todos
 
Je suis débutant en C++ et j'ai plusieurs petites questions...
 
1) Je n ai pas trop compris l interet de placer des variables dans le tas plutot que dans la pile... Que gagne ton au niveau des ressources memoires ? Si on créé tout dans le tas, est ce que ca peux poser probleme ? Comment se fait la repartition de la memoire entre le tas et la pile.... C est quoi la pile et le tas ????
 
2)Dans mon bouquin, ils disent d effacer toute les variable apres utilisation en leur affectant un pointeur, puis delete du pointeur et enfin affectation de la valeur nulle au pointeur....Mais qu en est il du nom du pointeur nul ? Consomme t il de l espace memoire ? Si oui, comment le virer ?
 
Mucha gracias

La pile est un espace mémoire réduit attribué au programme dés son lancement, servant principalement au stockage des variables locales. Elle n'est pas du tout faite pour stocker des grands tableaux ou autres objets volumineux en mémoire, on préfèrera généralement le tas pour ces objets.
 

J'ai rien compris !
Une variable locale est détruite dés la fin de la fonction dans laquelle elle est déclarée, donc c'est quoi cette histoire d'affecter un pointeur à une variable ?
Sinon, il faut effectivement savoir qu'à chaque new doit correspondre un delete, sinon ton programme fuit

Pour la premiere question, tu trouveras facilement la réponse avec google. Les 2 sont différents et ne servent pas à la même chose, point.
 
Pour la seconde question, je pense que tu parles de variables dynamiques (type *pointeur = new type[taille]), ce que tu ne précises pas (sinon ça n'a aucun sens ton histoire !) et que c'est à la FIN du programme que tu dois faire un delete sur ta variable et lui affecter la valeur NULL (ou éventuellement au milieu du programme si on parle d'une tres grosse variable, un grand tableau par exemple et qu'on veut libérer l'espace qu'il occupe). Oui un pointeur occupe une infime portion de mémoire (il faut bien qu'il existe quelque part !), mais tu n'as pas à t'en soucier, ce qui importe c'est la taille des données sur quoi il pointe.
Il faut effectivement supprimer les variables créées de cette façon lorsque tu arrives à la fin du programme (sinon leur espace reste en théorie occupé, même une fois le programme quitté, c'est pas propre. même si les OS récents savent composer avec ça et font le ménage eux même), mais pas la peine de le faire sans arrêt en plein programme, comme tu as l'air de le croire. Ca répond à la qestion ?

Ca repond en patrie a ma question, mais en fait je ne sais pas quand est ce que c est util (Je suppose que c est util pour de grosse variables)....Je vais prendre plusieur exemple:
 
1) Je créé une variable "int var"... Pour supprimer l'espace qu elle occupe avant la fin du programme, je "dois faire" int * pvar = var.... puis delete pvar.... et pvar=0 Mais ensuite, comment supprimer l 'espace qu occupe le pointeur et est ce qu il est important de supprimer cet espace memoire ?
 
2) Si je créé beaucoup de variable locales dans ma fonction "main" (une centaine ou des objet de classe), faut il que je les supprime ?
 
3) Maintenant, je pense que si j utilise des espaces memoire dans le tas, je dois les vider dans tous les cas...
int * pvar = new int
....
delete pvar
pvar=0
Mais encore une fois je ne retire pas l espace occupe par le pointeur....
 
4) Encore une chose, si je veux créé des variables, vaut il mieux faire des variables locales dans la pile ou créer des pointeur vers des espaces memoires du tas ? Dans quel cas vaut il mieux choisir l un par rapport a l autre ?
 
J espere que c est plus clair
 
(Si je pose ces questions ici, c est que je n ai pas reussi a bien comprendre exactement tout ca dans la documentation que j ai pu lire
 
Chao y muchas gracias à ceux qui ont déjà posté des réponse

Horreur !
 
Je sais pas avec quoi tu apprends, mais en effet, tu t'emmeles totalement les pédales !
 
On va pas te faire un cours particulier, donc je te conseille de rechercher au plus vite une meilleure méthode d'apprentissage

1) n'importe quoi
2) idem
3) vrai. conclusion parano
4) tu crées ta variable en fonction de sa taille mais avant tout en fonction de sa portée (sa durée d'utilisation)

Je crois que ma methode d apprentissage est la bonne
J utilise le Macmilan "Le Programmeur C++"... Le probleme vient de moi.... Je n ai pas d experience de la programmation en C++.... Je ne faisais que tu fortran, idl et Matlab a petit niveau.... Donc j apprend des choses sans vraiment savoir dans quels cas les utiliser et l avantage que j y trouverai....
 
PS: Pourquoi n importe quoi pour 1) ?

créer un define NULL 0 parce que 0 c'est bien joli mais au moins NULL on sait que c'est pour les pointeurs.
et aussi, ne supprime surtout pas une variable statique, imagines que tu l'utilises plus tard dans le code il va se passer quoi ?
et puis depuis quand on s'occupe de ces histoires de pile et de tas ? c'est le compilo qui gère ca voyons.
typiquement un argument (parametre) de fonctions vas de la pile (avec la sauvegarde des registres) et les variables vont dans le heap.

c'est déjà le cas. #include <cstddef>
 
mais la vrai question est : le compilateur le sait-il ?
 

par définition, tu ne peux pas faire ça
 

toi aussi t'as râté un chapitre

 
cstddef ? connais pas, perso j'aurais plutot dit que c'etait déja dans la SDK de l'OS.
 

 
ouf, c'est bien pour ca que taz a dit que c'etait n'importe quoi.
 

 
oups attention a pas parler trop vite.
 
bon, une chose est certaine, aucun besoin de se soucier de ca.
ca fait qq années que je programme en C++ et j'ai pas besoin d'y penser.
par contre tu peux tout a fait m'expliquer pourquoi je devrais et je considérerais ca.

... quand tu écris 'int i' tu sous-entend la classe de stockage 'auto', c'est-à-dire automatique, communément implémenté à l'aide d'une pile. quand tu écris 'int *p = new int', p est une variable automatique qui pointer vers une zone mémoire allouée dynamiquement distincte communément appelé 'tas' (ou 'free store' pour citer qui vous savez).
 
alors oui tu t'en préocuppes ... j'ai bien ton argument 'ca fait qq années que je programme en C++' ... ça laisse réveur

ah tiens, detail a noter, j'avais pas remarqué que c'etait toi meme qui m'avait quoter ! lol
bref
 
je comprend ce que tu me dis, mais je comprend pas pourquoi oui "on s'en préocupe". tu viens de me décrire objectivement les effets d'utilisation mais pas pourquoi ! continues
ah aussi, je prog pas en tant que professionnel
(en tout cas pas encore)
et tu peux jetter un oeil sur mon projet actuel:
www.serhum.fr.st
pour voir mon nivo koa

faire un delete pour chaque new, ça te parait pas s'en préoccuper ?
 
 
edit: quant à ton projet, le site est blindé de javascript, a part faire flasher mon écran et recharger la page, ça d/l quedalle

bien sur que si voyons ? mais je comprend tjs pas.
ce que je veux dire, c'est que quand on déclare une variable (ce que j'appelle "statique" en reference a mes anciennetés basicéennes) genre int i; donc par gestion automatique comme tu dis elle est automatiquement deletée par le compilo (ou plutot par la CRT) a la fin du programme, si ce n'est de la fonction.
donc pour l'instant pas vraiment réellement besoin de savoir où est ma variable si ?
ensuite, quand on a besoin d'objet dynamique, on utilise new, on créer un pointeur statique, on alloue de la mémoire,  on utilise, puis on delete quand on en a plus besoin.
(sans fautes ou bien avec une classe de vecteurs pour être en sécurité) enfin en gros, on regarde la surface du langage, on utilise son "medium-level" d'une certaine manière sans regarder la machinerie. et c'est pas ca qui empeche de faire des programmes fonctionnels.
 
ca peut etre autre chose en débugage je le recconnais
est-ce la, la vraie raison ?
 
edit:
des javascripts ?
curieu faudra ke je vois ca, j'ai un anti-pop ups avec mozilla donc je vois plus trop ca.
le site est créé par un pote a moi qui voulais apprendre le php.
il est logé sur un hebergeur, disons, volontaire, donc si ya des pubs je lui en jetterais un mot !

une variable automatique est désallouée dès que sa portée se finit.
 
mal nommer les choses c'est apporter un plus de désarroi à ce monde.
 
 
sinon je comprends rien à ta masturbation intellectuelle de newbie.

Si je comprends bien....
 
POur tout ce qui est variable local, je laisse la declaration se faire dans la pile, mais lorsqu il sagit d objet dans une classe, il vaut mieux les declarer dans le tas afin de pouvoir les supprimer et en ajouter d autre sans perdre d espace memoire parce qu il est possible de faire des delete....
 
Pour de gros tableau, il vaut certainement mieux les declarer dans le tas egalement, no.... ???

tu vois tu n'as rien compris. ce n'est pas la taille le facteur déterminant. c'est la durée de vie et si la quantité d'objets à créer est connue à la compilation.

 
Toi, tu as tout de meme un peu de mal !!!! Tu dis que je n i rien compris, mais tu ne donnes pas la solution !!!!
Expique moi au lieu de dire que je n ai rien compris....Donne un exemple !

faut le dire combien de fois ?

 
 
Et il faut te le redemander combien de fois ????
 
Tu ne me dis toutjours pas dans quel cas utiliser le tas plutot que la pile !!!!
 
Je suppose que pour des variables de longue portee je dois utiliser la pile et que si j ai des enregistrement (exemple: elements de classe) qui sont souvent effacé et créé, je vais utiliser le tas....
 
Et si la quantite d objet est connue a la compilation, je suppose qu il faut utiliser la pile....
 
Enfin, tu me dis qu elle sont les parametres a considerer pour choisir entre la pile et le tas, mais tu ne dis pas dans quel cas choisir l un par rapport a l utre !!!

déjà on ne raisonne pas sur pile/tas, on raisonne en terme de automatique/dynamique. et tu supposes très mal : c'est dingue, y a pas un moment ou tu réfléchis avant d'affirmer un truc.
 
tu sais ce que c'est la portée/durée de vie d'une variable ?
 
 
puisque de toutes façons tu ne comprends par l'exemple ...
 

qu'est-ce que tu peux dire de t et de s ?

t -> pile
s -> tas

on va prendre un petit exemple.
 
hein.
 
un jeu de course de voitures.
 
tu as auras des objets
"voiture"
"joueur"
et un objet "jeu" qui maintiens tout ce petit monde en collections
 
ça donnera un truc comme ça:
 
class Voiture
{
public:
    float longueur,largeur,vitesse_max,acceleration.....
};
 
class Joueur
{
public:
   int parties_gagnées;
   int parties_perdus;  
   Voiture *voiture_utilisée;
 
   AssigneNouvelleVoiture();
};
 
class Jeu
{
public:
    collection<Voiture*> Voitures;
    collection<Joueur*> Joueurs;
 
    CreeNouveauJoueur();
    ActualiseLeMonde();
};
 
pour Jeu::CreeNouveauJoueur(), mettons que tu veuilles créer un nouveau Joueur (logique ), tu vas faire un truc dans ce  goût:
 
 
Jeu::CreeNouveauJoueur()
{
    // création d'un -nouveau- Joueur
    // l'objet est crée dans le tas, et maintenu par un pointeur
    // temporaire dans la pile (qui sert aux choses
    // temporaires locales à une fonction)
 
    // le pointeur sert uniquement à maintenir l'emplacement
    // de l'instance de l'objet Joueur
    // il est important de ne pas le paumer
    // après le pointeur lui-même sera automatiquement  
    // entre "" supprimé
 
    Joueur *NouveauJoueur=new Joueur;  
 
    // ajout du -nouveau- joueur à la collection
    // pour ne pas perdre celui-ci
    Joueurs.ajoute( NouveauJoueur );
 
    // on crée une nouvelle voiture
    // qui est pilotée par le joueur
 
    Voiture *jVoiture=new Voiture;      
    NouveauJoueur->voiture_utilisée=jVoiture;
 
    Voitures.ajoute(jVoiture);
    // donc là, le "Jeu" connait les Joueurs, les Voitures, et chaque     Joueur a sa propre voiture
    // ceci dit, on pourrait supposer des voitures pilotées par de l'IA,  
    // donc avoir plus de Voitures que de Joueurs
}
 
Maintenant que l'on tout les objets et leurs relations, on peut se balader dans la collection de Voitures et actualiser leur position:
 
Jeu::ActualiseLeMonde()
{
    Voiture *VoitureCourante;
 
    for( VoitureCourante = chaque Voiture de la collection Voitures )
    {
         VoitureCourante->CalculeNouvellePosition();
         VoitureCourante->TesteCollisions()
         etc...
         etc...  
    }
}

remplacer pile/tas par automatique/dynamique pour rester cohérent avec Taz.

non?

mauvais exemple ... même pas correct au niveau des types ...

 
de ?
mon truc ?

Ouais...moi j dis ca......
Et Tu es vraiment une tete de con !!! Tu n as pas compris que je n affirme rien !!!!! Et oui....ne t inquiete pas...je reflechi....Mais quand on n est pas pedagogue on devrait se retenir d expliquer !!!! Si tu savais pourquoi j apprends le C++, tu ne me dirais peutetre pas que je ne reflechi pas !!!!
Toujours est il que tu ne repond toujours pas a ma question....Apparement tu es plus la pour me prendre pour un con....alors abstient toi de venir sur ce topic si ca te gonfle de m aider a comprendre.... J commence en C++, et je n ai pas d experience.....donc je ne sais pas comment exploiter correctement ce language....Je vais devoir commencer comme si j etais deja confirmer en C++ et je me dois de savoir reagir a des situation que je n ai pas encore vecu.... Je n ai pas la possibilite de tout voir sur le tas !!!!
 
A bon entendeur
 
Et en effet... pour moi, t c est un tableau dans la pile et s un pointeur vers un espace memoire reserve dans le tas !
 
de plus s est de taille fixe et s non

je me marre. tu ne pas dire que tu réfléchis et après sortir des
 
celui c'est la pile,
lui c'est ça,
et ce dernier le tas
 
on est pas du genre à faire du tout cuit, d'ailleurs si je disais juste qui va où, ça ne ferait qu'augmenter ta parano 'tas/pile, je veux tous dans le tas'
 

je t'assure que quand j'écris int[n] c'est pas int[2*n]. commence déjà par choisir tes mots.
 
et tu n'as pas parlé de la différence de portée entre t et s.  l'emplacement mémoire de t ou de s, on s'en fiche bien, on en saurait rien, ça serait pareil.

 
ha tu voudrais ptet des collection<Voiture *>, oui effectivement ce serait  plus clair.

voui.

oki. (j'ai fait ça à froid j'ai pas bouffé ce matin, et je suis mode dalle donc )

il me semble que le contenu du pointeur sera dans le tas, et le pointeur lui même dans la pile (variable automatique). C'est ça la question ? (c'est plus explicite avec des mots que avec ou sans étoile )
 
Celà dit c'est pas systématique toutes ces histoires, même si c'est la règle de base.

moi je comprends pas votre entêtement de savoir où est qui ? c'est l'aspect fonctionnel qui prime !

C'est clair qu'on a absolument pas à s'en soucier...
(si ce n'est qu'il faut etre un tout petit peu vigilant avec la pile quand on fait de la récursivité par exemple, mais bon)

 
complètement.

Alor je reformule ma question...pourquoi la memoire est elle geree differement pour les variables automatiques et les variables dynamiques.... Et quelle est la difference dans cette gestion ???
Je fais du C++ depuis 1 mois pour me preparer a un travail.... Je ne cherche jamais de tout cuit et je m en fou de l opinion de ce qui n aiment pas repondre aux questions (D ailleurs ce n est pas a eux que je m interesse) Je ne demande pas non plus qu on me simplifi la vie en me cachant des choses....Je ne suis pas non plus un cretin !!! Je veux comprendre ce que je fais, un point c est tout ! (Je ne fais pas non plus de parano....Si il n y a pas de differences entre la pile et le tas, je m en fou.... Mon probleme, je le repete encore une fois, c est que je n ai pas d experience de programmation en C++ et je n aurais pas le temps d en avoir avant mon travail...Alors je cherche a etre le plus au point possible et a sauter le maximum de problemes en les pensant theoriquement avant !!! Sur ce, Merci a ceux qui s interessent vraiment aux questions des autres

et bien ce n'est plus une question de C++ maitenant.
 
la différence de portée/durée de vie est assez indépendante du langage. (tu la retrouve dans tous les langages)
 
attrappe un bouquin d'architecture des CPUs.
attrappe un bouquin sur l'assembleur.
attrappe un bouquin sur le fonctionnement des OS...
 
comprendre le concept de pile, de tas, c'est indépendant du langage, mais dépendant de la logique générale de la durée de vie des choses, des CPUs (pour la pile), et de la conception générale d'un OS et de la manière de distribuer dynamiquement les ressources aux process(us) (pour les allocations dynamiques).

écoute : fais du C++ et te ne soucies pas de l'implémentation. Comme dit bjone, tout ça est trop dépendant. La gestion c'est le boulot du support d'exécution, pas le tiens, ça ne t'intéresse pas, ça ne t'es d'aucune utilité. Tu apprends à conduire une voiture, tu t'en fiche bien de comment elle fonctionne. Tu sais juste comment tourner le volant et régler la vitesse, c'est tout ce dont tu as besoin pour atteindre ta destination.