Pointer/fr

│ Deutsch (de) │ English (en) │ suomi (fi) │ français (fr) │ русский (ru) │

Généralités sur les pointeurs

Ce que sont les pointeurs :

• Un pointeur est une référence à un emplacement mémoire.
• Un pointeur est du type de données entier qui stocke une adresse de mémoire.
• Un pointeur désigne le premier octet d'une variable ou un objet.
• La taille d'un pointeur dépend du processeur et du système d'exploitation, soit 4 ou 8 octets.

Exemple:

var
   ptr1: ^Integer;  // typé
   ptr2: Pointer;   // non typé

Travailler avec des pointeurs typés est plus rapide qu'avec des pointeurs non typés.
Cependant les pointeurs non typés sont plus flexibles car non liés à un type particulier.

Pointeur typé

Exemple d'utilisation d'un pointeur typé sur un type de donnée simple :

var
  a, b: Integer;  // "a" et "b" sont des variable de type Integer.
  p: ^Integer;    // "p" est un pointeur, il peut accueillir l'adresse d'une variable du type Integer.
begin
  a := 500;       // Affectation d'une valeur correcte à la variable "a".
  p := @a;        // La variable "p" de type Pointer reçoit maintenant l'adresse qui a été attribuée à la variable "a".
  b := p^;        // La variable "b" de type entier récupère la valeur à l'adresse données par "p" soit celle de la variable "a".
  p := nil;       // La variable "p" ne référence dorénavant plus rien.
                  // Le pointeur "p" pourra désigner une nouvelle adresse de mémoire.
end;

Avertissement: Tout tentative d'accès à l'espace mémoire via un pointeur valant Nil provoque une erreur à l'exécution.

Exemple d'utilisation d'un pointeur typé sur un enrtegistrement :

type
   TNewRecord = record
      Wert1: ShortString;
      Wert2: ShortString;
      Wert3: ShortString;
   end;
var
   p: ^TNewRecord;
begin
   New(p);                      // Allocation de mémoire pour un variable de type TNewRecord.
   p^.Wert1 := 'Test';          // Affectation d'un champ de donnée du TNewRecord par le pointeur.
   p^.Wert2 := 'TestTest';      // Affectation d'un champ de donnée du TNewRecord par le pointeur.
   p^.Wert3 := 'TestTestTest';  // Affectation d'un champ de donnée du TNewRecord par le pointeur.
   Dispose(p);                  // Libération de la mémoire allouée au TNewRecord.
                                // Les valeurs des champs de données sont alors perdues.
end;

Pointeur non typé

Exemple de définition d'un pointeur non typé :

var
   ptr2: Pointer;

Nouvelle allocation et libération de la mémoire :

begin
  ...
  GetMem(ptr2,4);          // Integer est de 32 Bit, donc une taille de 4 octets
  Integer(ptr2^) := 2048;  // Affectation de la valeur
  FreeMem(ptr2);           // Libération de la mémoire
  ...
end;

Types de pointeurs typés prédéfinis

Il existe, par exemple dans Free Pascal et autres, les pointeurs prédéfinis suivants.

• Pour les type caractères :
  • PChar (Pointeur pour le type de donnée Char)
  • PAnsiChar (Pointeur pour le type de donnée AnsiChar)
  • PWideCahr (Pointeur pour le type de donnée WideChar)
  • PUnicodeChar (Pointeur pour le type de donnée UnicodeChar)
• Pour les types entiers non signés :
  • PByte (Pointeur pour le type de donnée Byte)
  • PWord (Pointeur pour le type de donnée Word)
  • PDWord (Pointeur pour le type de donnée DWord)
  • PCardinal (Pointeur pour le type de donnée Cardinal)
  • PLongword (Pointeur pour le type de donnée Longword)
• Pour les types entiers signés :
  • PShortint (Pointeur pour le type de donnée Shortint)
  • PSmallint (Pointeur pour le type de donnée Smallint)
  • PInteger (Pointeur pour le type de donnée Integer)
  • PLongint (Pointeur pour le type de donnée Longint)
  • PInt64 (Pointeur pour le type de donnée Int64)
• Pour les types réels flottants :
  • PSingle (Pointeur pour le type de donnée Single)
  • PDouble (Pointeur pour le type de donnée Double)
  • PExtended (Pointeur pour le type de donnée Extended)
  • PComp (Pointeur pour le type de donnée Comp)
  • PCurrency (Pointeur pour le type de donnée Currency)

Exemple de définitions de pointeurs typés:
Exemple 1:

var
  ptr1: ^Integer;  // créé un pointeur typé pour le type de donnée Integer

Allocation et libération de mémoire :

begin
  ...
  New(ptr1);     // Réserve un emplacement de mémoire pour stocker sa valeur
  ptr1^ := 1;    // Affecte la valeur à l'emplacement mémoire
  Dispose(ptr1)  // libère la mémoire pour un usage ultérieur
                 // ce qui veur dire que la valeur est perdue
  ...
end;

Exemple 2:

function funTest: string;
var
  ptrZeiger: PInteger; // Type prédéfini de pointeur sur Integer dans Free Pascal
  { on pourrait déclarer de manière équivalente : ptrZeiger: ^Integer }
  intZahl: Integer; 
begin

  result:= '';
  intZahl := 4;  // une valeur pour la variable

  ptrZeiger := @intZahl; // le pointeur désigne maintenant la variable IntZahl
  result := Inttostr(ptrZeiger^); // Retourne la valeur désignée par ptrZeiger soit aussi celle de intZahl.

end;

Liens externes

Pour comprendre la notion de pointeur, vous pouvez lire cette excellente introduction aux pointeurs (fr)