En fait ca dépend pas uniquement de la mémoire. Oula j´ai l´impression de faire un cours de C++ lol.

Le fait d´utiliser les pointeur car c´est de ca qu´on parle lorsque l´ont utilise les new et delete fait que tu peux manipuler et " faire voyager " ton object très rapidement.

Ta variable Array qui est un int*
La seule chose qu´elle contient c´est une adresse vers un espace mémoire où est stocké ton tableau.
Donc quand tu passe à une fonction ton Array, tu déplace seulement une adresse ( moins de 32bits).

Avec juste un " int Array[10] "
Si tu passe Array dans une fonction, tu recopie tout ton tableau donc 10 fois la taille d´un int.

Evidament il existe des manière de contrer ca, regarde dans ton boukin le passage par référence, par pointeur et par copie. Tout devrait etre expliqué

lockscash :

Même des variables alloué statiquement peuvent l´être dans la pile plutot que dans le tas. C´est le cas des variables locales.
Seul les variables globales sont initialisé dans le tas à ma connaissance.

Il faut savoir de plus que l´accès à la pile est plus rapide et que sous windows la taille de la pile est extensible quasiment à l´inifinie. Donc il y a tout interet à toujours créer des variabls locales plutot que globales ( en plus du coté propre par opposition à la prolifération de variables globale).

En fait, un new aloue de l´espace memoire. Ton pointeur indique où dans la memoire elle se trouve.

Du coup, si tu efface ton pointeur, la memoir elle existe toujours.

C´est pour cela que certains n´aiment pas les pointeurs brut, et utilisent des pointeurs inteligents ( smart pointer). C´est une façon d´encapsuler les pointeur en faisant en sorte que des qu´un espace memoire n´est plus alloué, il est effacé.

N´abuse pas des new, utilise les que si tu en a vraiment besoin. Sa arive tres vite les fuites de memoires, surtout quand on debute ( Mais chez la froggies team, on a un memory manager pour les detecter )

Alors en fait.
La pile à un accès beaucoup plus rapide mais est limité en taille ( de l´ordre du méga) donc ne peut etre utilisé uniquement pour stocker des int, double etc...

Le tas à un accès peut etre plus lent mais sa taille est quasi infini ( faux, ca dépend de la mémoire de ton PC. Mais on pourrait dire quasi infini car ca fait beaucoup)
Les objects et variables Globales sont stocké dans le tas. Et il faut déclarer avec des ´new ´ les gros objects pour que ceux-ci aussi.

Essaye ca :
int Array[6000000]
J´en ai fait l´expérience, ta pile elle aime pas

oki merci pour les réponses les gars

Ya pas de mal

mais , avec la gestion statique , on pouvait pas supprimer mais changer les donné des variables!
cela revient donc un peu au meme....

quel est donc lme vrai avantage?

on pouvait pas supprimer mais changer les donné des variables!

Tu peux repetter en francais ?

oui!
on ne pouvait pas supprimmer les variables que l´on avait crée , mais on pouvait changé les donnés qu´on leur avait mises ( exemple on a int 10 , on peut lui mettre un 12)

sonic66 > Voila, c´est un gros avantage de la gestion dynamique : tu crees qq chose au moment ou tu en as besoin, et tu liberes quand tu n´en as plus besoin !

Les possibilités sont énormes !
Vivent les pointeurs ! !!

et , y a til dautres avantages?

tu crées un int a;
alors le a n´existe que dans plouf, et n´existe plus hors de plouf.

si tu crees un int* p=new int;
alors un int est créé en mémoire, il existe de partout, jusqu´a ce que tu le deletes...
tu peux l´appeler de n´importe ou, il suffit de connaitre l´adresse de la ou il est...
( c´est le role du pointeur, garder une adresse . ..)

lappeler de partout? c´est a dire?

normalement chaque variable a ce qu´on appelle un porté.

int a
void function() {
int a;
}

les deux variables porte le meme non mais ce ne sont pas les meme.

la variable ayant une porté local, le deuxieme, sera utilisé en prorité par rapport a la variable global ( la premiere)
de plus a la fin de ta finction ta variable crée a l´interieur de celle ci sera detruite automatiquement.

a l´inverse si tu fais
void function() {
int * a;

• a="tagasok"

}
cout < < *a;
delete a;

la le a que tu creer sera accessible de partout jusqu´a sa destruction par le delete.
partout, c´est toute le fonction les classes les fichiers...etc, et meme d´autres applications.

mais a condition de connaitre a ( pas *a).
a represente ici l´adresse en memoire de ton objet et *a represente son contenu

Correction de TomTomClancy :

" a l´inverse si tu fais
void function() {
int * a;

• a="tagasok"

}
cout < < *a;
delete a;"

Rien de dynamic dans tout ça : pointeur ne veux pas forcement dire porté de partout. la chaine de caracter " tagasok" aura une porté juste dans fonction. En plus, c´est un int* alors que tu devais penser a fair ça avec un char*.

donc voici la corection :
void function() {
char* a;
*a=new char[strlen("tagasok")+1];
strcpy(a,"tagasok");
}

tu ne peux pas faire ça :
cout < < *a;
delete a;
car la porté de a est juste dans fonction()
Là, t´a une fuite de memoire car t´a alloué de la place que tu ne peux pas recuperer.

corection de moi meme

a=new char[strlen("tagasok")+1];

Mais tu peu envoyer un pointeur en parametre ou utiliser une variable globale de type char* afin de pointer vers la memoire aloué

lol desolé je crois que je fais trop de php en ce moment ^^

int a="tagazok" non mais vraiment

merci de m´avoir aidé!