Module 5 : Programmation avancée en Pascal**
Module 5 : Programmation avancée en Pascal
Ce module explore des concepts avancés du langage Pascal, notamment les pointeurs, les structures
dynamiques, les sous-programmes avancés, et les techniques d'optimisation. Ces notions permettent
de développer des programmes plus performants et modulaires.
1. Les pointeurs
Les pointeurs sont des variables qui stockent l'adresse mémoire d'autres variables. Ils permettent une
gestion dynamique de la mémoire.
1.1 Déclaration d’un pointeur
Syntaxe :
Var
P: ^Integer; { P est un pointeur vers un entier }
1.2 Utilisation des pointeurs
Exemple :
Var
P: ^Integer;
Nombre: Integer;
Begin
New(P); { Alloue de la mémoire pour un entier }
P^ := 42; { Assigne une valeur à la mémoire pointée }
WriteLn('Valeur pointée : ', P^); { Affiche 42 }
Dispose(P); { Libère la mémoire allouée }
End.
1.3 Pointeurs et tableaux dynamiques
Exemple :
Var
Tableau: ^Array[1..10] of Integer;
i: Integer;
Begin
New(Tableau); { Alloue de la mémoire pour un tableau }
For i := 1 To 10 Do
Tableau^[i] := i * 2; { Initialise le tableau }
For i := 1 To 10 Do
WriteLn('Tableau[', i, '] = ', Tableau^[i]);
Dispose(Tableau); { Libère la mémoire }
End.
2. Structures de données dynamiques
Les structures comme les listes chaînées, les piles, et les files permettent de gérer des données de
manière dynamique.
2.1 Listes chaînées
Exemple : Implémentation d'une liste chaînée simple.
Type
PNode = ^Node;
Node = Record
Data: Integer;
Next: PNode;
End;
Var
Head, Temp: PNode;
Begin
New(Head); { Crée le premier nœud }
Head^.Data := 10;
Head^.Next := Nil;
New(Temp); { Crée un deuxième nœud }
Temp^.Data := 20;
Temp^.Next := Nil;
Head^.Next := Temp; { Relie les deux nœuds }
Temp := Head; { Parcourt la liste }
While Temp <> Nil Do
Begin
WriteLn('Valeur : ', Temp^.Data);
Temp := Temp^.Next;
End;
End.
2.2 Piles (Stack)
Exemple :
Type
Pile = ^Node;
Node = Record
Data: Integer;
Next: Pile;
End;
Var
Top: Pile;
Procedure Push(Var Top: Pile; Value: Integer);
Var
Temp: Pile;
Begin
New(Temp);
Temp^.Data := Value;
Temp^.Next := Top;
Top := Temp;
End;
Function Pop(Var Top: Pile): Integer;
Var
Temp: Pile;
Begin
If Top = Nil Then
Halt(1);
Temp := Top;
Pop := Temp^.Data;
Top := Top^.Next;
Dispose(Temp);
End;
Begin
Top := Nil;
Push(Top, 10);
Push(Top, 20);
WriteLn('Pop : ', Pop(Top));
WriteLn('Pop : ', Pop(Top));
End.
3. Sous-programmes avancés
3.1 Paramètres de type variable
Les paramètres de type variable permettent de passer des références à des fonctions ou procédures.
Exemple :
Procedure Swap(Var A, B: Integer);
Var
Temp: Integer;
Begin
Temp := A;
A := B;
B := Temp;
End;
Var
X, Y: Integer;
Begin
X := 5;
Y := 10;
Swap(X, Y);
WriteLn('X = ', X, ', Y = ', Y); { Affiche X = 10, Y = 5 }
End.
3.2 Fonctions récursives
Les fonctions récursives s'appellent elles-mêmes pour résoudre des problèmes comme le calcul de
factorielle ou la recherche dans des structures.
Exemple : Factorielle
Function Factorielle(N: Integer): Integer;
Begin
If N = 0 Then
Factorielle := 1
Else
Factorielle := N * Factorielle(N - 1);
End;
Begin
WriteLn('Factorielle de 5 : ', Factorielle(5));
End.
4. Techniques d’optimisation
4.1 Utilisation efficace de la mémoire
Libérez toujours la mémoire allouée dynamiquement avec Dispose .
4.2 Optimisation des boucles
Préférez les calculs à l'intérieur de la boucle plutôt que les appels à des fonctions.
4.3 Réduction de la complexité
Évitez les algorithmes avec une complexité élevée, comme O(n²), lorsque des alternatives plus
performantes existent.
5. Applications pratiques
5.1 Gestion d'une base de données simple
Exemple : Gestion d’un annuaire téléphonique.
Type
Contact = Record
Nom: String[30];
Numéro: String[15];
End;
Var
Annuaire: Array[1..100] of Contact;
i, NbContacts: Integer;
Begin
NbContacts := 0;
{ Ajouter un contact }
Inc(NbContacts);
Annuaire[NbContacts].Nom := 'Ali';
Annuaire[NbContacts].Numéro := '0123456789';
{ Afficher les contacts }
For i := 1 To NbContacts Do
Begin
WriteLn('Nom : ', Annuaire[i].Nom);
WriteLn('Numéro : ', Annuaire[i].Numéro);
End;
End.
5.2 Algorithme de tri
Exemple : Tri par insertion.
Procedure TriParInsertion(Var Tableau: Array of Integer);
Var
i, j, Clé: Integer;
Begin
For i := 1 To High(Tableau) Do
Begin
Clé := Tableau[i];
j := i - 1;
While (j >= 0) And (Tableau[j] > Clé) Do
Begin
Tableau[j + 1] := Tableau[j];
Dec(j);
End;
Tableau[j + 1] := Clé;
End;
End;
Var
T: Array[0..4] of Integer = (5, 3, 4, 1, 2);
i: Integer;
Begin
TriParInsertion(T);
For i := 0 To High(T) Do
WriteLn(T[i]);
End.
6. Conclusion
Ce module a présenté des concepts avancés comme les pointeurs, les structures dynamiques, et les
sous-programmes complexes. Ces notions sont essentielles pour concevoir des applications Pascal
performantes et robustes. Pour des exercices pratiques ou des applications spécifiques, je peux vous
assister davantage !
