Articles de Delphi

POINTEUR

On accède habituellement à une variable par son nom. 

Nb1:=Nb2;

On localise l'adresse par le nom de la variable, mais on peut aussi accéder à son contenu directement par son adresse. L'adresse sert à localiser un emplacement en mémoire. Un pointeur est une constante ou variable qui possède l'adresse d'une variable. Le pointeur pointe vers la variable concernée.

Les pointeurs sont plus rapides et utilisent moins de mémoire que si on utiliserait directement la variable. Les variables utilisent la mémoire locale qui est en quantité minime. Lorsqu'on utilise un pointeur, seul ce dernier est dans la mémoire locale. Les éléments pointés sont eux dans la mémoire globale qui est beaucoup plus grande. On peut aisément se rendre compte de l'importance d'utiliser les pointeurs.

pointeur

Le type pointer est utilisé en delphi pour désigner un pointeur. On utilise @ pour avoir l'adresse de la variable 

var
  ptrNote : Pointer;
  Note : integer;
begin
  ptrNote := @Note;
end;

La variable stocke l'adresse l'adresse de ptrNote. C'est un pointeur non typé.

Les pointeurs ne pointent pas obligatoirement vers une adresse, on peut leur assigner une valeur nulle avec le mot «nil». On utilise beaucoup cette affectation afin de vérifier si le pointeur pointe quelque part.

var ptrNote : pointer;
begin
  ptrNote := nil;
end;

Le type pointer déclare un pointeur sur n'importe quoi. Le type de donnée pointé ne peut être connu même si on peut accèder à son contenu. Ce n'est vraiment pas pratique dans un programme. On doit utiliser des pointeurs spécifiques à un type pour régler le problème. Un pointeur sur un integer, sur un real... Au lieu d'utiliser directement le pointeur, on préfèrera créer un nouveau type et on déclarera les variables ou les paramètres en utilisant ce nouveau type. Pointeur vers s'écrit en delphi ^, ce qui équivaut à * du c.

Langage c Delphi 
int *ptrNote;
int Note=74;
ptrNote=&Note;
 
type
  pNote:=^integer;
var
  Note:pNote;
begin
  Note^:=74;
end;
 

type
pNote:=^integer;

Dans cet exemple, la variable pNote pointe sur un type integer. On déclare ainsi un pointeur sur un integer. pNote := ^long; Ici pNote serait un pointeur sur un long. Lorsque ^ est avant un type de donnée (déclaration) comme dans les exemples ci-dessus, le ^ signifie pointe sur. Le ^ est avant le type de donnée, c'est typique à la déclaration.

variable :=^ <type de donnée>

Lorsqu'on veut effectuer des opérations sur le contenu de la valeur pointé par le pointeur, on utilise encore ^. Le ^ est après le nom du pointeur comparativement au cas de déclaration qui est situé après.

pNote ^:= 54;

Dans cette exemple, on affecte 54 à la valeur contenu à l'adresse pointé par le pointeur. On effectue ainsi une affectation

Les éléments pointés par les pointeurs sont gérés dynamiquement et c'est au programmeur qui doit coordonner, le tout. La gestion de l'élément pointé se fait en deux étapes


Un pointeur doit être créé avant de pouvoir l'utiliser. La procédure «new» initialise le pointeur, le nom du pointeur doit être passé en paramètre. Un espace en mémoire lui est ainsi alloué. Des problèmes surviennent aussitôt si cette étape n'est pas faite. Lorsque l'utilisation du pointeur sera terminée, il faudra le détruire afin de remettre l'espace alloué au système et d'augmenter ses performances. La procédure «dispose» détruit l'espace alloué par le pointeur. Le nom du pointeur doit être passé en paramètre.

type
  pNote = ^Integer;
var
  Note : pNote;
begin
  new(Note);       //initialisation du pointeur
  Note^ := 54;     //affectation du pointeur
  dispose(Note);   //destruction du pointeur
end;

Opération sur les pointeurs


Les pointeurs sont limités aux opérations d'affection et de comparaison.

Affectation

Les pointeurs doivent pointer vers le même type avant de pouvoir faire une affectation 

>var
  PNote : ^Integer;
  PNbEleve :^Integer;
begin
  new(PNote);
  new(PNbEleve);
  PNote := PNbEleve;
  dispose(PNote);
  dispose(PNbEleve);
end;

L'affectation ci-dessus est possible, car les deux pointeurs pointent sur des integers. Étant donnée qu'après cette affectation les deux pointeurs pointent au même endroit, il faut détruire qu' un seul pointeur. Il est aussi possible de copier le contenu d'un pointeur dans un autre pointeur, mais les deux pointeurs doivent pointer sur le même type de donnée.

var
  PNote :^Integer;
  PNbEleve :^Integer;
begin
  new(PNote);
  new(PNbEleve);
  PNote :=PNbEleve;
  PNote^ := 5;
  dispose(PNote);
end;

Comparaison

La comparaison sert à savoir si les pointeurs pointent au même endroit. Les signes «=» et «<>» peuvent être utilisés. 

if PNbEleve = PNote then

Si cette ligne de code retourne true (vrai), les deux pointeurs pointent à la même adresse.

Pointeurs d'enregistrements

Ce type de pointeur est tout simplement un pointeur vers un enregistrement. On utilise beaucoup ce type de pointeur. Prenons comme exemple un enregistrement du chapitre 5 

type TInfoClient = record
  Prenom:string[20];
  Nom:string[20];
  Adresse:string[30];
  Ville:string[20];
  CodePostal:string[6];
end;
  PInfoClient:TInfoClient;
var 
  InfoClient:PInfoClient;
begin
  New(InfoClient);
  InfoClient^.Prenom := 'Paul';
  InfoClient^.Nom := 'Houle';
  InfoClient^.Adresse := '1024 Des Chênes';
  InfoClient^.Ville := 'Montreal';
  InfoClient^.CodePostal := 'J4S2R4';
  Dispose(InfoClient);
end;

Pour mieux comprendre les pointeurs, nous allons étudier les listes.

Liste

Les listes sont une suite d'éléments mis les uns à la suite des autres. On les utilise constamment dans la vie de tous les jours. En programmation, leurs utilités ne sont plus à faire. Les listes peuvent être utilisées pour y mettre n'importe quel type de donnée. Souvent, on les utilise avec les enregistrements.

liste

Chaque noeud possède un champ information et un champ pointeur qui pointent sur le prochain noeud. Lorsqu'il n'y a pu de noeud, le dernier pointeur pointe sur nulle c'est alors là fin de la liste.

Opération sur les pointeurs

Création


type //Création des informations pour la liste
  TInfoClient = record
  Prenom:string[20];
  Nom:string[20];
  Adresse:string[30];
  Ville:string[20];
  CodePostal:string[6];
end;

Déclaration


type //Déclaration de la liste
  PListClient = ^TListClient;
  TListClient = record
  InfoClient :TInfoClient;
  ProchainNoeud:PListClient;
end;

Construction


var
  PremierClient,TempClient:PListClient;
begin
  PremierClient:=nil; //Initialise le premier pointeur
  new(TempClient); //Crée un noeud temporaire
  TempClient^.InfoClient.Prenom:='Paul';
  TempClient^.InfoClient.Nom:='Prenom';
  TempClient^.InfoClient.Adresse:='23 Nobert';
  TempClient^.InfoClient.Ville:='Longueuil';
  TempClient^.InfoClient.CodePostal:='J3S1H4';
  TempClient^.ProchainNoeud:=PremierClient;
end;

La dernière ligne permet d'ajouter le noeud à la liste afin qu'il pointe à la même adresse que le premier pointeur.

liste

Cette instruction permet de faire pointer PremierClient au début de la liste 

PremierClient:=TempClient;

liste

Un petit programme illustrant les principes de base des listes est disponible en téléchargement ici

Article écrit par: Marc Collin


Page valide XHTML 1 Strict