Module 2 : Concepts avancés du langage
Pascal**
Module 2 : Concepts avancés du langage Pascal
Dans ce module, nous approfondissons les concepts de Pascal pour permettre la création de
programmes plus sophistiqués et structurés.
1. Structures de données avancées
1.1 Les tableaux (Arrays)
Les tableaux sont des structures qui permettent de stocker plusieurs valeurs du même type.
Déclaration et utilisation :
Var
Notes: Array[1..5] of Integer; { Tableau de 5 entiers }
i: Integer;
Begin
For i := 1 To 5 Do
Begin
Write('Entrez la note ', i, ': ');
ReadLn(Notes[i]);
End;
WriteLn('Voici les notes : ');
For i := 1 To 5 Do
WriteLn('Note ', i, ': ', Notes[i]);
End.
1.2 Les enregistrements (Records)
Les enregistrements permettent de grouper différents types de données sous une seule structure.
Exemple :
Type
Étudiant = Record
Nom: String[50];
Âge: Integer;
Moyenne: Real;
End;
Var
E1: Étudiant;
Begin
[Link] := 'Ali';
E1.Âge := 20;
[Link] := 15.5;
WriteLn('Nom : ', [Link]);
WriteLn('Âge : ', E1.Âge);
WriteLn('Moyenne : ', [Link][Link]);
End.
1.3 Les fichiers typés
Les fichiers typés permettent de manipuler des structures complexes dans des fichiers.
Exemple : Écrire et lire un enregistrement dans un fichier :
Type
Étudiant = Record
Nom: String[50];
Âge: Integer;
End;
Var
Fichier: File of Étudiant;
E1, E2: Étudiant;
Begin
Assign(Fichier, 'é[Link]');
Rewrite(Fichier);
[Link] := 'Fatima'; E1.Âge := 22;
Write(Fichier, E1);
Close(Fichier);
Reset(Fichier);
Read(Fichier, E2);
WriteLn('Nom : ', [Link], ', Âge : ', E2.Âge);
Close(Fichier);
End.
2. Programmation modulaire
2.1 Utilisation des unités (Units)
Les unités permettent de diviser un programme en plusieurs fichiers pour une meilleure
organisation.
Exemple : Création d'une unité pour des calculs mathématiques :
Unit Calculs;
Interface
Function Carré(x: Real): Real;
Function Cube(x: Real): Real;
Implementation
Function Carré(x: Real): Real;
Begin
Carré := x * x;
End;
Function Cube(x: Real): Real;
Begin
Cube := x * x * x;
End;
End.
Utilisation de l’unité dans le programme principal :
Program TestCalculs;
Uses Calculs;
Var
x: Real;
Begin
Write('Entrez un nombre : ');
ReadLn(x);
WriteLn('Carré : ', Carré(x):4:2);
WriteLn('Cube : ', Cube(x):4:2);
End.
3. Gestion des chaînes de caractères
3.1 Manipulation des chaînes
Concaténation :
Var
S1, S2, S3: String;
Begin
S1 := 'Bonjour, ';
S2 := 'monde !';
S3 := S1 + S2;
WriteLn(S3); { Affiche : Bonjour, monde ! }
End.
Longueur d'une chaîne :
WriteLn('Longueur : ', Length(S3));
Extrait d'une sous-chaîne :
WriteLn('Sous-chaîne : ', Copy(S3, 10, 5)); { Affiche : monde }
3.2 Conversion de types
Conversion entre chaînes et nombres :
Var
S: String;
N: Integer;
Begin
S := '123';
Val(S, N);
WriteLn('Nombre : ', N);
End.
4. Gestion des erreurs et exceptions
4.1 Les blocs try...except
Pour gérer les erreurs à l'exécution.
Var
x, y, z: Integer;
Begin
Try
Write('Entrez deux nombres : ');
ReadLn(x, y);
z := x Div y;
WriteLn('Résultat : ', z);
Except
WriteLn('Erreur : Division par zéro.');
End;
End.
5. Applications avec structures complexes
5.1 Tri d'un tableau
Exemple : Tri par sélection :
Var
Tableau: Array[1..5] of Integer;
i, j, Min, Temp: Integer;
Begin
For i := 1 To 5 Do
Begin
Write('Entrez un nombre : ');
ReadLn(Tableau[i]);
End;
For i := 1 To 4 Do
Begin
Min := i;
For j := i + 1 To 5 Do
If Tableau[j] < Tableau[Min] Then
Min := j;
Temp := Tableau[i];
Tableau[i] := Tableau[Min];
Tableau[Min] := Temp;
End;
WriteLn('Tableau trié : ');
For i := 1 To 5 Do
WriteLn(Tableau[i]);
End.
5.2 Recherche dans un tableau
Recherche linéaire :
Var
Tableau: Array[1..5] of Integer;
i, Rechercher: Integer;
Trouvé: Boolean;
Begin
For i := 1 To 5 Do
Begin
Write('Entrez un nombre : ');
ReadLn(Tableau[i]);
End;
Write('Entrez le nombre à rechercher : ');
ReadLn(Rechercher);
Trouvé := False;
For i := 1 To 5 Do
If Tableau[i] = Rechercher Then
Begin
Trouvé := True;
Break;
End;
If Trouvé Then
WriteLn('Nombre trouvé.')
Else
WriteLn('Nombre non trouvé.');
End.
Conclusion
Le module 2 développe les compétences avancées en Pascal, telles que l'utilisation des tableaux,
enregistrements, unités, gestion des erreurs, et manipulation des chaînes. Ces concepts permettent de
résoudre des problèmes plus complexes de manière efficace et structurée.
Si vous avez besoin d'exercices ou de projets pratiques, faites-le-moi savoir !
