Programmation avec DELPHI les structures de données composées

Cours programmation avec DELPHI les structures de données composées, tutoriel & guide de travaux pratiques Delphi en pdf.

Affectation

Entrées-sorties
Dans la suite nous allons transformer notre premier programme pour qu’il produise un autre effet. Les instructions, que nous allons y ajouter vont toutes se placer entre begin et end.
Les instructions write et writeln (comme write mais suivi d’un saut à la ligne) permettent d’afficher à l’écran des données. Ces instructions sont suivies d’un point virgule comme toute instruction Delphi.
Exemples :
writeln(4785); {affiche le nombre 4785}
writeln(47.85); {affiche le nombre décimal 47,85 (point décimal !!!)}
writeln(′delphi′); {affiche la chaîne de caractères « delphi »}
Retenons ici la règle de syntaxe importante :
Chaque instruction se termine par un point-virgule « ; ».
Devant end on peut laisser de côté ce point virgule.
L’instruction readln fait attendre le programme jusqu’à ce que l’utilisateur presse la touche «enter». Cela est nécessaire ici pour laisser à l’utilisateur le temps de lire l’affichage avant que le programme ne se termine et ne ferme la fenêtre.
Après avoir ajouté ces instructions au programme, la partie centrale de celui-ci se présente sous la forme suivante.
begin
writeln(4785);
writeln(47.85);
writeln(′delphi′);
readln;3
end.
Si nous lançons programme maintenant, alors l’affichage est le suivant :
4785
4.78500000000000E+0001
delphi_
Le curseur dans la quatrième ligne indique que le programme attend une entrée de la part de l’utilisateur. Pressez « enter » pour terminer le programme.
L’affichage de 47.85 peut surprendre. Delphi utilise d’office une écriture, lourde mais précise, en notation scientifique à lire 4.785 ⋅101 .
L’instruction writeln permet de formater l’affichage de la façon suivante :
3 Un tel « ; » devant end n’est pas nécessaire, mais nous allons quand-même le laisser systématiquement et mettre l’accent sur les choses importantes !
writeln(47.85:10:8); {10 chiffres au total, dont 8 derrière la virgule) writeln(4785:6); {affichage à 6 places, 2 blancs suivis des 4 chiffres 4785 }
Apportez ces modifications dans le programme et relancez-le pour vous en convaincre. Essayez d’autres paramètres d’affichage pour en constater l’effet !
Ces formatages sont nécessaires pour garantir une bonne présentation à l’écran, surtout si on prévoit d’afficher beaucoup d’informations, éventuellement en colonnes ou en tableaux.

Les opérations arithmétiques

Delphi permet d’effecteur les opérations arithmétiques et mathématiques usuelles :
L’addition « + », la soustraction «-», la multiplication « * », la division « / » donnent les résultats attendus.
Les parenthèses peuvent être utilisées comme en mathématiques et elles peuvent être imbriquées
à plusieurs niveaux. Les crochets et accolades qui apparaissent dans des expressions mathématiques doivent être remplacées par des parenthèses. Delphi effectue les expressions arithmétiques en appliquant correctement les règles de priorité.
Les opérations div et mod sont seulement définies pour des nombres entiers : div donne le quotient (entier) et mod le reste de la division euclidienne.
15 div 7 = 2 et 15 mod 7 = 1 car 15 = 7 * 2 + 1
Les fonctions sqrt (racine carrée, « square root ») et sqr (carré, « square ») sont aussi définies et utilisées comme en mathématiques mais les parenthèses sont obligatoires.
Exercice 2-2
Effectuez (sans l’ordinateur) les expressions suivantes :
a) 86 div 15
b) 86 mod 15
c) (5-(3-7*2)*2)*2
d) sqrt(sqr(9)+19)
e) 145-(145 div 13)*13
f) 288 div 18
g) 288/18
Variables
Un concept fondamental de l’informatique est celui de la variable. Comme en mathématiques une variable représente une certaine valeur. Cette valeur peut être un nombre, une chaîne de caractères, un tableau, …
Le nom d’une variable n’est pas limité à une seule lettre. Un nom de variable admissible (accepté par le système) commence par une lettre et peut être suivi d’une suite de symboles qui peuvent être des lettres, des chiffres ou le blanc souligné « _ » (« underscore »). Un nom valable sera appelé identificateur dans la suite. Vu que le nombre de variables d’un programme peut être très grand, il est utile de choisir des identificateurs qui donnent une indication sur l’usage envisagé de la variable.
Par exemple : Dans un programme calculant une puissance les noms de variables base et exposant seraient appropriés. Il est important de noter que ce choix est seulement fait pour simplifier la lecture et la compréhension du programme et que la signification éventuelle du nom échappe complètement à Delphi.
Delphi ne distingue pas entre majuscules et minuscules. Les identificateurs a et A ne peuvent donc être discernés. Dans la suite nous n’utiliserons que des lettres minuscules.
Type d’une variable
Pour des raisons d’organisation de la mémoire, il est nécessaire de déclarer au début du programme chaque variable et le type associé. Nous utiliserons dans la suite les types integer, real, boolean, char, string.
Le type real demande plus d’attention. Vu que l’écriture décimale d’un nombre réel (mathématique) peut nécessiter une infinité de chiffres décimaux une représentation fidèle ne peut pas être garantie dans l’ordinateur. Chaque langage de programmation impose des contraintes aux nombres. En Delphi un nombre de type real est représenté par un nombre un virgule flottante (« floating point »). C’est une notation scientifique ou la mantisse peut avoir jusqu’à 15 chiffres décimaux significatifs et l’exposant est compris entre –324 et +308. Ces bornes sont assez grandes pour garantir le bon fonctionnement de presque tout programme raisonnable.
Le type boolean qui admet seulement les deux valeurs true et false peut surprendre. Ce type est utilisé par Delphi pour représenter l’état de vérité (par exemple d’une condition). Une expression comme a<5 aura comme valeur true si a est effectivement inférieur à 5 et false dans le cas contraire.
Dans un programme, un caractère ou une chaîne de caractères sont entourés du symbole « ‘ » (apostrophe). Si la chaîne contient elle-même un apostrophe, alors il faut en mettre deux de suite sinon Delphi pense que cet apostrophe termine la chaîne. Ainsi l’expression « l’ordinateur », s’écrit ‘l »ordinateur’ en Delphi. Il ne faut surtout pas mettre de guillemets «  » » comme on a l’habitude de les mettre dans un texte. Lorsque Delphi affiche un caractère ou une chaîne de caractères par une instruction write ou writeln, alors les apostrophes au début et à la fin sont omis. De même, un double apostrophe à l’intérieur d’une chaîne est affiché comme simple apostrophe. Il est aussi déconseillé d’utiliser des lettres accentuées, car leur affichage en console n’est pas correct.

Déclaration d’une variable

Avant la première utilisation dans un programme, une variable doit impérativement être déclarée. Toutes les déclarations de variables suivent directement le mot réservé var et se présentent sous la forme :
var <ident_a1>,<ident_a2>,…,<ident_an>: <type_a>;
<ident_b1>,<ident_b2>,…,<ident_bm>: <type_b>; …;
La syntaxe est à respecter scrupuleusement :
• Différents identificateurs de variables de même type sont séparés par une virgule (« , »).
• L’identificateur et le type sont séparés par un deux-points (« : »).
• Le type est suivi d’un point-virgule (« ; »)
Les déclarations se trouvent avant le bloc begin … end.
Exemple :
program Project1;
{$APPTYPE CONSOLE}
var {déclarations de variables}
a,exposant:integer;
base,puissance:real;
mot:string;
begin
{instructions du programme}
end.
Cette déclaration permet au compilateur de réserver efficacement pour chaque variable l’espace mémoire nécessaire pour stocker la valeur ultérieure.
L’affectation
Jusqu’à présent les variables ont été déclarées mais elles ne représentent pas encore de valeur déterminée. L’opération qui consiste à attribuer une valeur à une variable est appelée affectation et elle respecte la syntaxe suivante :
<nom_de_variable> := <expression>;
Par exemple :
a:=45;
base:=12.34;
puissance:=3*3*3*3;
mot:=′test′;
Delphi effectue d’abord l’expression à droite de « := » et affecte (attribue) le résultat obtenu à la variable dont le nom se trouve à gauche de « := ».
Pour que l’affectation soit possible, il faut que le résultat de l’expression de droite existe et soit du même type que la variable !
Ensuite le nom de la variable peut apparaître dans une expression.
Par exemple
nombre:=6; la valeur 6 est affectée à la variable nombre
writeln(nombre+2); afficher nombre+2, c’est-à-dire afficher 8
L’expression de droite peut contenir aussi des variables y compris celle qui se trouve à gauche de l’affectation !
nombre:=6 ; la valeur 6 est affectée à la variable nombre
nombre:=nombre+2; effectuer le membre de droite : nombre+2=8 et affecter le
résultat 8 comme nouvelle valeur à la variable nombre
writeln(nombre); l’effet de l’instruction est donc nombre:=8;
afficher la valeur actuelle de nombre, donc 8.

Initialisation d’une variable

Il est important de constater que la valeur d’une variable peut varier (d’où le nom) au cours de l’exécution du programme. La première affectation d’une variable est appelée initialisation de la variable. Avant l’initialisation, la variable a une valeur non définie ! L’initialisation d’une variable doit précéder l’apparition de la variable dans une expression. En particulier une affectation comme terme:=terme+1; n’est utile que si la variable terme a été initialisée auparavant. Sinon le membre de droite, contenant terme n’est pas défini. Il est important de remarquer que le fait de ne pas initialiser la variable ne va pas empêcher le programme de démarrer, mais le résultat sera vraisemblablement faux!
Exercice 2-3 (résolu)
Les variables a, b et c sont de type integer. Faites un tableau reprenant la valeur de chaque variable après chaque ligne. Un « ? » indiquera que la valeur de la variable n’est pas connue à cet instant !

1 Introduction 
1.1 Généralités
1.2 Cycle de développement
1.3 Types d’applications.
1.4 Exemple d’un cycle de développement
2 Affectation
2.1 Entrées-sorties
2.2 Les opérations arithmétiques
2.3 Variables
2.4 Type d’une variable
2.5 Déclaration d’une variable
2.6 L’affectation
2.7 Initialisation d’une variable
2.8 L’instruction readln
2.9 Différents types d’erreurs
3 Structure alternative 
3.1 Problème introductif
3.2 Syntaxe
3.3 Les conditions (expressions logiques)
3.4 Exercices
4 Structure répétitive 
4.1 Introduction
4.2 Exemple
4.3 Terminaison d’une boucle
4.4 Boucles for.
4.5 Un algorithme efficace
4.6 Exercices
5 Fonctions et procédures
5.1 Les fonctions
5.2 Les procédures
5.3 Portée
5.4 Passage des variables dans une fonction ou une procédure
6 Les structures de données composées
6.1 Les tableaux
6.2 Les enregistrements.
7 Delphi
7.1 Introduction
7.2 Les fichiers utilisés en Delphi
7.3 L’approche Orienté-Objet
7.4 Passage Pascal – Delphi – un premier exemple
7.5 Calcul de la factorielle
7.6 Equation du second degré
7.7 Vérification du numéro de matricule
7.8 Une petite machine à calculer
7.9 Calcul matriciel – utilisation du composant StringGrid
8 La récursivité
8.1 Exemple.
8.2 Définition : « fonction ou procédure récursive »
8.3 Etude détaillée d’un exemple
8.4 Fonctionnement interne
8.5 Exactitude d’un algorithme récursif
8.6 Comparaison : fonction récursive – fonction itérative
8.7 Récursif ou itératif ?
8.8 Exercices
9 Comptage et fréquence
9.1 Algorithme de comptage
9.2 Fréquence d’une lettre dans une liste
10 Recherche et tri
10.1 Introduction
10.2 Sous-programmes utiles
10.3 Les algorithmes de tri
10.4 Les algorithmes de recherche

………