Je ne comprend pas les pointeurs

Dans ce cas précis tu ne devrais pas avoir besoin de ^mma...

La différence est purement technique...
il y a le nom : mma (qui identifie ta variable) et le pointeur ^mma (qui localise la position mémoire de ta variable)

tu peux modifier le contenu de ta variable sans changer le pointeur à condition d'utiliser la même taille mémoire.
Si tu veux augmenter dynamiquement la taille mémoire d'un objet (impossible sur un array) il te faudra réafecter le pointeur

y a pas un bons cours sur les pointeurs (je ne veux pas le cours de développer)
merci

Récemment j'ai lu une question qui concernait un algorithme utilisant des pointeurs : ici
La réponse que j'y est faite est très imagée, mais elle te permettrai peut-être de voir une explication détaillé (sur un exemple) d'un programme nécessitant l'utilisation de pointeurs.

Bonsoir,
Comme le dit KX, le pointeur est en fait l'adresse de ton objet en mémoire.
C'est à la fois très pratique et très contraignant :

- tu ne manipules plus qu'une adresse, donc un objet très léger (en général la taille d'un entier). Cela est super pratique dans le cas où tu as des structures de données assez lourdes, et que tu en as beaucoup : la mémoire utilisée peut être considérablement réduite en utilisant des pointeurs.
C'est surtout vrai dans le fait que lorsque tu fais appel à une fonction prenant un objet en paramètre (j'entends par objet tout objet des langages orientés objet, toute structure, tout type primitif...), une copie de ton objet est placé dans la pile, et ça peut être très lourd (imagine un programme récursif par exemple). Avec les pointeurs, tu as moins de chances d'avoir un débordement de pile, et c'est plus performant car les objets à copier sont plus légers.

- tu peux écrire ce que tu veux dans la zone mémoire (tu connais la taille de la zone allouée), donc tu peux écrire ce que tu veux dans cette zone mémoire. C'est très puissant (tu as un contrôle énorme), mais très dangereux à la fois si tu ne gères pas bien tes pointeurs (si par exemple tu écris des données trop volumineuses, tu dépasses la zone mémoire allouée, et là soit tu as un segmentation fault, dans le meilleur des cas, soit tu écrases les données adjacentes à ta zone mémoire, ce qui généralement fait tout planter ;).
L'écrasement des données adjacentes peut aussi être intentionnel ! C'est une technique courante utilisée par les hackeurs (le buffer overflow), qui consiste à déclencher un comportement inattendu du programme, en utilisant un pointeur sur une zone mémoire, et en écrasant les données adjacentes avec des valeurs consciencieusement choisies.

En espérant t'avoir un peu éclairé.

comment en disent que les pointeur a une grande capasité de memoire est nous nous l'avons déclaré (ex pointeur vers un enregistrement)

J'ai fait un tours sur google et voici ce que je viens de comprendre !!! si je me trempe corrigez moi :)

Voici un exemple :

#####################
TYPE pointeur=^type_de_la_variable_pointée

ex : TYPE tpoint=^tval; (* pointe sur des TVAL *)
tval=record
valeur:integer;
suivant:tpoint
end;
VAR p1:tpoint;
#####################

donc chaque fois quand écrit NEW(p1^) il nous alloue une mémoire d'un enregistrement puis on fait DISPOSE(p1^) pour finir et si on veux créer une autre enregistrement on fait NEW(p1^) est c'est pour ça quand dit que nous créant une grande memoire

est ce que je me trempe
si ca est vrais, si on a 10 enregistrement quand a créer 10 fois avec new(p1^) comment peut on aller au 4 enregistrement

merci

oui, c'est ça.
par contre, si tu fait 10 new, tu écrases à chaque fois.
Je ne sais plus très bien comment le pascal gère la mémoire, mais soit les valeurs de 1 à 9 sont effacer, soit elles sont perdu car elle ne sont récupérer nulle part.
Dans le deuxième cas, tu as une fuite de mémoire, c'est à dire que ton programme prend de plus en plus de place.