•
Les pointeurs
1.Problématique.
2. Les Variables dynamiques.
3.Les pointeurs.
4. Opérations sur les variables dynamiques.
5.Comparaison et affectation des pointeurs.
6.Utilisation sans allocation des pointeurs.
7.Pointeurs de tableaux.
8. Pointeurs d'enregistrements.
9. Les structures récursives.
**********************************************************
1-Problématique.
Notion d'allocation mémoire - Variables
La Mémoire Centrale (MC) est formée par des cases numérotées. Chaque case peut stocker un octet Une variable est une zone contigüe en MC (une case ou un ensemble de cases qui se suivent). Sa taille (en nombre de cases) dépend du type de la variable (ex: un entier occupe 4 cases, un réel occupe 8 cases, ...etc). L'adresse d'une variable est le numéro de sa première case.
Ex: en Pascal on peut déclarer une variable entière comme suit:
Var x : integer;
dans ce cas, x est le nom donné pour référencer l'emplacement mémoire associé à la variable.
En Pascal : x := 10;
Le contenu de l’adresse mémoire référencée par x est 10.
Notion de zones mémoires (1)
• zones mémoires utilisées par l’exécution d’un programme
Un programme qui s’exécute utilise au moins deux zones mémoires, appelées segments :
• le segment de code : contient les instructions du programme;
• le segment de données : contient les données utilisées par le programme.
Le segment de données est découpé en trois parties :
• la zone statique : contient les variables statiques, c’est-à-dire les variables ayant une durée de vie égale à celle du programme : c’est le cas des variables globales
• la pile : sert à gérer les éléments du programmes dont la durée de vie est limitée à un bloc : c’est le cas desparamètres des appels de fonctions/procédures, des variables locales Elle sert également à renvoyer les résultats des fonctions.
• le tas : tout ce qui reste... Un programme ne peut accéder directement aux emplacements du tas. Par contre, on peut allouer des emplacements dans le tas et les référencer ensuite à l’aide de pointeurs. La gestion du tas est à la charge du programmeur.
Durée de vie des allocations mémoire
- Allocation statique : Variables définies au niveau du bloc principal Vie durant l’exécution du programme
-Allocation dynamique : Variables locales aux procédures et fonctions Vie durant l’exécution proprement dite des procédures et fonctions Exemple
Type t_matrice=array[1..100,1..100] of real;
Var A,B : t_matrice;
A exige 60000 octets !!
Ex: trouver tous les nombres premiers <= n (avec n un paramètre donné) et les stocker en mémoire.
On n’a aucune idée sur la taille à réserver au départ.
Autoriser l’allocation et la désallocation en cours d’exécution.
2. Variables dynamiques : principe Elles sont :
1. Réservées 2. Utilisées 3. Supprimées
àgestion dynamique (manuelle) de leur durée de vie Comment référencer de telles variables?
Solution = adressage indirect à l’aide de variables pointeurs
3 -Notion de pointeur
Un pointeur est une variable qui : - a un nom
- pointe une zone mémoire qui doit avoir été réservée au préalable (il pointe une adresse Mémoire)
*Une adresse est tout simplement un nombre qui repère un emplacement en mémoire
*lorsque l'élément pointé fait plus d'un seul octet, c'est l'octet de début (le premier de la suite d'octets qui stockent l'élément) qui est pointé.
Déclaration :
Déclaration
P : pointeur sur entier ; En pascal :
Var p :^
integer
P contient l’adresse d’une variable de type entier .( la variable pointée).
Cette déclaration n’effectue pas de réservation Elle réserve bien un emplacement nommé P mais uniquement pour pouvoir y placer plus tard une adresse : celle de la valeur pointée.
4. Opérations sur les variables dynamiques:
4.1 - Création d’une variable dynamique :
allouer(p) ; alloue dynamiquement une zone de mémoire (zone réservée au cours de l’exécution du programme, et non à sa compilation). La variable p pointe sur cette zone qui pourra être utilisée comme n’importe quel entier.
En pascal :
New (p) ;
P^ est appelé variable pointée ( variable dynamique ) . 4.2.Utilisation :
P^ : permet d’accéder à la variable pointée par P ; Exemple :
déclaration
ptr1 : Pointeur sur entier ptr2 : Pointeur sur entier début
allouer (ptr1) ; //
ptr1^←2;//
ptr2 ← ptr1 ;//
fin
Rq : Par rapport à nos explications sur le segment de données, le pointeur lui-même est alloué dans la partie statique du segment de données tandis-que l’emplacement pointé est alloué sur le tas.
4.3.La constante NIL :
Le constant pointeur NIL (en Pascal) indique l'absence d'adresse.
Donc, par exemple en Pascal, l'affectation p := NIL, veut dire que p ne pointe aucune variable.
Remarque :
Il ne faut jamais utiliser l'indirection (^ en pascal) avec un pointeur ne contenant pas l'adresse d'une variable, il y aura une erreur .
-Pour tester si un pointeur pointe vers un emplacement, il suffira alors de tester s’il est égal à NIL : if P = NIL then ...
-Un pointeur valant NIL existe (il est déclaré) mais ne pointe sur rien.
4.4. Destruction d’une variable dynamique :
Libérer ( p) : permet de désallouer ( libérer ) l'espace mémoire alloué ( réservé ) pour p et de la rendre au système. Ceci signifie que p ne peut plus être utilisé à moins qu'il ne soit associé de nouveau à une instruction allouer (p).
En pascal : dispose( p );
Nous sommes revenus à la situation de départ.
5-Pointeurs : comparaison et affectation:
Un pointeur d’un type T peut être comparé avec tout autre pointeur de type T ou avec la valeur nil. Il en va de même pour l’affectation.
Exemple :
program pointeurs2;
type T_Pointeur_Entiers = ^integer;
var Ptr_Int1, Ptr_Int2 : T_Pointeur_Entiers;
begin
new(Ptr_Int1);
Ptr_Int1^ := 10;
Ptr_Int2 := Ptr_Int1;
writeln('Ptr_Int2 pointe sur ', Ptr_Int2^);
dispose(Ptr_Int1);
writeln('Ptr_Int2 pointe sur ', Ptr_Int2^);
end. quelles sont les 2 valeurs affichées pour Ptr_Int2^ ? 6.Pointeurs : utilisation sans allocation :
On peut également utiliser les pointeurs sans avoir recours à l’allocation dynamique : ils servent alors d’alias pour des variables déjà créées.
Pour ce faire, on peut utiliser l’opérateur d’indirection : placé devant un nom de variable, il renvoie l’adresse mémoire de celle-ci, qui peut donc être affectée à un pointeur.
La forme générale est : ptr := @variable ;
Rq : Les pointeurs sont typés ce qui signifie qu’ils ne peuvent recevoir que des adresses
d’emplacements du type pour lequel ils ont été définis. On ne peut affecter une adresse de réel à un pointeur d’entier, par exemple.
Exemple :
program POINTEURS_1;
var
ent1, ent2 : INTEGER;
ptr_ent_1, ptr_ent_2 : ^INTEGER; begin
ent_1 := 10; ent_2 := 100;
ptr_ent_1 := @ent_1;
ptr_ent_2 := @ent_2;
writeln('ptr_ent_1 pointe sur ', ptr_ent_1^);
writeln('ptr_ent_2 pointe sur ', ptr_ent_2^);
ptr_ent_1 := ptr_ent_2;
writeln('ptr_ent_1 pointe sur ', ptr_ent_1^);
writeln('ptr_ent_2 pointe sur ', ptr_ent_2^);
ptr_ent_1^ := 2000;
writeln('entier_1 = ', ent_1,'ent_2 = ', ent_2);
ptr_ent_1^ := ptr_ent_1^ + ent_1;
writeln('entier_2 = ', ent_2);
ent_2 := ptr_ent_2^ * 10;
writeln('entier_2 = ', ent_2);
end.
Quelles sont les 2 valeurs affichées pour entier_2 ?
7.Pointeur de tableaux :
Les variables dynamiques peuvent être de n'importe quel type, simple ou complexe. Voici un exemple en Pascal montrant l'allocation dynamique de tableaux :
type
T_tab = array[1..100] of integer; { def d'un type tableau de 100 entiers } var
p : ^T_tab; { allocation statique de la var p (un pointeur) } i : integer; { allocation statique de la var i (un entier) } begin
new( p );
{ un tableau de 100 entiers vient d'être alloué dynamiquement, son adr est dans p } p^[1] := 10;
p^[2] := 3;
p^[3] := p^[1] * 2 + 5;
dispose( p );
{ maintenant le tableau n'existe plus, on a plus le droit de manipuler p^ } { mais on peut créer un autre tableau on utilisant le même pointeur } new( p );
for i:=1 to 100 do p^[i] := 5432;
8.Pointeur d’enregistrements Type
TSexePersonne = (Feminin, Masculin);
TPersonne = record
Nom,Prenom,CodePostal,Adresse, Ville: string;
Sexe: TSexePersonne;
end;
PPersonne = ^TPersonne;
Pointeurs de records : l ’occupation de la mémoire Il faudra donc éviter cela : array[1..1000] of TPersonne au profit de cela : array[1..1000] of PPersonne
9.Les structures récursives
Une structure récursive est une structure dont l’un des cha.mps est du type de la structure.
La définition suivante n’est cependant pas correcte : type T_Personne = record
nom : string;
pere, mere : T_Personne;
end;
Rq : T_Personne n’est connu qu’après le end; de la définition : Pascal ne connaît donc pas la taille mémoire qu’il faut réserver pour les champs pere et mere.
Les pointeurs, et la possibilité d’anticiper la définition d’un type permettent de corriger ce problème : type T_Ptr_Personne = ^T_Personne;
T_Personne = record nom : string;
pere, mere : T_Ptr_Personne; {pointeur}
end;
C’est cette méthode que l’on utilisera pour toutes les structures de données gérée dynamiquement, telles que les listes.
