CyBWarrior

Un peu comme les langages C et C++, le Turbo Pascal permet d’acceder à la memoire et aux variables par le biais
de ce que l’on appelle les pointeurs.
Cependant, la syntaxe des pointeurs en Pascal reste rudimentaire et peu maniable.

Mais commençons par définir ce qu’est un pointeur. Un pointeur est une variable qui contient l’adresse memoire
d’une autre variable.
Et oui, parce qu’une variable n’est rien d’autre qu’un emplacement reservé dans la mémoire de l’ordinateur. Le
pointeur va alors pointer sur cet emplacement de mémoire.
En Pascal, les pointeurs sont typés selon le type de la variable qu’ils doivent pointer.
Par exemple, si ils doivent pointer sur une variable du type Integer, il seront du type Integer.

Pour déclarer une variable du type pointeur, on utilise l’opérateur ^ (accent circonflexe), suivi du
type de la variable.
Par exemple :

var Pointeur : ^Integer;{Un pointeur sur une variable Integer}

Il est egalement possible d’utiliser la syntaxe suivante, qui peut être un passage obligatoire dans certains
cas :

Type PInteger = ^Integer;

var Pointeur : PInteger;

Ensuite, on accede au contenu, c’est à dire à la variable pointée, en utilisant le même opérateur (^),
mais cette fois ci, en le placant derière le nom de la variable :

var Pointeur : ^Integer;

begin
writeln(Pointeur^);{Le contenu de la variable pointee}
end.

À ce stade là, la valeur renvoyée est arbitraire car elle dépend du contenu de la mémoire, vu que le pointeur
n’a pas été initialisé. En effet, il pointe sur un emplacement de la mémoire non-determiné.
Nous allons maintenant ajouter une nouvelle variable du type Integer (c’est à dire du type que
le pointeur doit pointer) que nous appelerons Entier et faire pointer notre variable Pointeur
sur celle-ci.
Pour ce faire, on utilise l’opérateur @ (aroba) pour affecter l’adresse mémoire de notre nouvelle variable
au pointeur.
Attention! Ici, nous n’accedons pas au contenu mais à l’adresse. Il ne faut donc pas
utiliser l’operateur ^.

varPointeur : ^Integer;
Entier : Integer;

begin
Pointeur := @Entier;{On fait pointer Pointeur sur Entier}
Entier := 45;{On affecte 45 à Entier}
writeln(Pointeur^);{Sortie -> 45}
end.

La dernière ligne affiche 45. C’est tout à fait normal, puisque nous avons modifier le contenu
pointé par Pointeur, c’est à dire la variable Entier.
Mais ce comportement ne nous est pas inconnu : rappellez vous des procedures capables de modifier le contenu
d’une variable passée en argument, pour peu que l’on utilise le mot-clef var. Et oui, il s’agit
aussi de pointeurs. Seulement, le Pascal, un peu comme le Basic mais dans de moindres mesures, tente de nous les
dissimuler pour simplifier au maximum le langage.
Bien sur, ça marche aussi en sens inverse :

varPointeur : ^Integer;
Entier : Integer;

begin
Pointeur := @Entier;{On fait pointer Pointeur sur Entier}
Pointeur^ := 45;{On affecte 45 à Pointeur^}
writeln(Entier);{Sortie -> 45}
end.

Simple question : que ce serait-il passé si au lieu du type Integer, on avait utiliser le type
Real pour Entier?
Le résultat aurait bien entendu pas été inattendu, vu que le codage des variables n’est pas le même. Si dans
la pratique, une variable du type Integer peut parfaitement être pointée par un pointeur du type
LongInt, il est preferable d’eviter ce genre de pratique. En effet, que faire d’une variable du type
String pointée par un Real?

Si on veut neutraliser un pointeur à un moment donné, il faut affecter la valeur NIL à son adresse :

Pointeur := NIL;{Neutralisation}

Ainsi, le pointeur ne pointe sur plus rien de précis, comme au départ.