2024

Programmer avec Delphi

BTP 04
JIMMY FRANCICE MENAVOARA

IFT TOAMASINA
1 Cours d'Algorithmique
1. Introduction à l'Algorithmique

L'algorithmique est la science de la conception, de l'analyse et de la mise en œuvre des

algorithmes. Un algorithme est une séquence finie d'instructions permettant de résoudre un
problème ou d'effectuer une tâche spécifique. L'efficacité d'un algorithme dépend de sa
capacité à résoudre le problème de manière correcte et optimale.

2. Définition d'un Algorithme

Un algorithme est une suite d'instructions précises qui doivent être exécutées dans un ordre
spécifique pour atteindre un objectif. Les caractéristiques principales d'un algorithme sont :

• Finitude : L'algorithme doit se terminer après un nombre fini d'étapes.

• Précision : Chaque instruction doit être claire et sans ambiguïté.
• Entrées : L'algorithme reçoit des données d'entrée.
• Sorties : L'algorithme produit des résultats ou des données de sortie.

3. Représentation d'un Algorithme

Les algorithmes peuvent être représentés de plusieurs façons :

• Texte : Description sous forme de texte ou pseudo-code.

• Organigramme : Diagrammes de flux illustrant le processus de décision et d'action.
• Pseudo-code : Langage simplifié pour écrire des algorithmes de manière plus
structurée.

4. Structures de Contrôle

Les algorithmes utilisent différentes structures de contrôle pour déterminer le flux d'exécution
:

• Séquences : Exécution des instructions de manière linéaire.

• Conditions : Prise de décision basée sur des conditions (par exemple,
IF...THEN...ELSE).
• Boucles : Répétition d'instructions (par exemple, WHILE, FOR, REPEAT...UNTIL).

5. Exemples de Structures de Contrôle

5.1. Conditionnelle

Exemple : Trouver le plus grand de deux nombres.

• Pseudo-code :
Explication : Si a est supérieur à b, alors afficher a, sinon afficher b.

5.2. Boucle

Exemple : Calculer la somme des nombres de 1 à N.

• Pseudo-code :

Explication : Initialiser la somme à 0, puis ajouter chaque nombre de 1 à N à la somme.

6. Analyse des Algorithmes

Pour évaluer la performance d'un algorithme, on utilise souvent les notions de complexité :

• Complexité en temps : Mesure du temps d'exécution en fonction de la taille des

données d'entrée.
• Complexité en espace : Mesure de la mémoire utilisée en fonction de la taille des
données d'entrée.

Les notations courantes sont :

• O(1) : Complexité constante.

• O(n) : Complexité linéaire.
• O(n^2) : Complexité quadratique.
• O(log n) : Complexité logarithmique.

7. Algorithmes de Tri

Les algorithmes de tri sont utilisés pour organiser les données. Quelques algorithmes de tri
courants :

• Tri à bulles (Bubble Sort) : Échange successif des éléments adjacents jusqu'à ce que
la liste soit triée.
• Tri par insertion (Insertion Sort) : Insère les éléments dans une sous-liste triée à
chaque itération.
• Tri rapide (Quick Sort) : Divise et conquiert en utilisant un pivot pour partitionner les
éléments.

8. Exercice Pratique

Énoncé : Écrire un algorithme pour trier une liste de nombres en utilisant le tri à bulles.
 • Pseudo-code :

• Explication : Compare et échange les éléments adjacents jusqu'à ce que la liste soit
triée.

1.1 9. Conclusion
L'algorithmique est une compétence clé en programmation, car elle permet de résoudre des
problèmes de manière efficace et élégante. La pratique régulière de la conception et de l'analyse
des algorithmes renforce la compréhension et améliore les capacités de programmation.
2 Introduction au Langage Pascal
1. Qu'est-ce que Pascal ?

• Pascal est un langage de programmation structuré développé par Niklaus Wirth dans
les années 1970.
• Il est utilisé principalement pour l'enseignement de la programmation et pour le
développement de logiciels.

2. Structure de Base d'un Programme Pascal

Un programme Pascal typique ressemble à ceci :

• program NomDuProgramme; : Déclaration du programme avec un nom.

• begin et end. : Délimitent le début et la fin du programme.

3. Variables et Types de Données

En Pascal, vous devez déclarer les variables avant de les utiliser :

• integer : Entier
• real : Nombre à virgule flottante
• string : Chaîne de caractères

4. Opérations de Base

Vous pouvez effectuer des opérations arithmétiques simples :

 5. Instructions Conditionnelles

Les instructions conditionnelles permettent de prendre des décisions :

6. Boucles

Les boucles permettent d'exécuter un bloc de code plusieurs fois :

• Boucle while : Exécute le bloc tant que la condition est vraie.

Boucle for : Exécute le bloc un nombre spécifique de fois.

Boucle repeat…until : Exécute le bloc au moins une fois puis vérifie la condition
 7. Procédures et Fonctions

Les procédures et les fonctions permettent de structurer le code :

• Procédure : Effectue des actions sans retourner de valeur.

Fonction : Effectue des calculs et retourne une valeur.

8. Commentaires

Les commentaires sont importants pour expliquer le code :

3 Introduction à Delphi
3.1 Composants Simples

Le développement des ordinateurs personnels a conduit à l'introduction de systèmes

d'exploitation multitâches et multi-utilisateurs tels que Microsoft Windows. Cependant, cela a
rendu le processus de création de logiciels beaucoup plus complexe. Les environnements de
développement intégrés (IDE) visuels et les systèmes de développement rapide d'applications
(RAD) ont été créés par les leaders du marché pour faciliter l'interaction avec les systèmes
d'exploitation, réduire le temps de codage et améliorer la qualité du code.

La programmation visuelle est un processus de création d'applications logicielles dans

lequel un utilisateur peut simultanément concevoir, éditer, déboguer et tester l'application en
utilisant un IDE visuel. En d'autres termes, la programmation visuelle est une combinaison de
deux processus interconnectés : concevoir visuellement une fenêtre d'application et écrire le
code.

Delphi, un compilateur Pascal puissant avec de nombreuses améliorations significatives pour

la création d'applications Windows, a été publié pour la première fois en 1996. C'est un
système de développement logiciel de haut niveau avec un ensemble d'outils intégrés pour le
développement complet d'applications ; c'est un outil pour le développement rapide
d'applications. Les concepts de conception visuelle et de programmation basée sur les
événements sont les piliers de l'idéologie de Delphi. L'utilisation de ces concepts améliore
considérablement les processus de conception des applications et réduit considérablement le
temps de développement.

La conception visuelle permet aux utilisateurs de disposer l'application et de voir les résultats
du processus avant même de commencer le programme proprement dit. Il y a d'autres
avantages également : pour attribuer une valeur de propriété à un contrôle ou à un élément de
l'application, il n'est pas nécessaire d'écrire plusieurs lignes de code. Il suffit de modifier cette
valeur dans une fenêtre des propriétés. Ce changement générera ou mettra automatiquement à
jour le code.
 L'environnement de développement intégré Delphi

L'environnement de développement intégré (IDE) Delphi est un système multi-fenêtres

configuré en ajustant les éléments de l'interface utilisateur. Pour chaque action effectuée par le
programmeur dans la fenêtre, Delphi modifie automatiquement le code du programme sous-
jacent.

Principales Composantes de l'IDE Delphi :

• Menu Principal (MainMenu) : Le Menu Principal est situé généralement en haut de

la fenêtre de l'IDE et contient les commandes essentielles telles que "Fichier",
"Édition", "Affichage", "Projets", et "Aide". Ces menus permettent de gérer les
fichiers du projet, d'effectuer des modifications dans le code, et d'accéder à diverses
fonctionnalités de développement.
• Barre d'Outils (ToolBar) : La Barre d'Outils est généralement située juste en dessous
du Menu Principal. Elle offre des boutons pour les actions courantes telles que
l'exécution du programme, la mise en forme du code, et l'accès rapide aux outils de
conception et de débogage. Ces boutons permettent de simplifier le processus de
développement en offrant des raccourcis pour les tâches fréquentes.

L'IDE Delphi facilite la programmation en permettant une interaction directe avec l'interface
graphique et en mettant à jour automatiquement le code associé à ces interactions.
Menu Principal (MainMenu) : Le Menu Principal contient tout ce dont vous avez besoin
pour gérer votre projet. Il est généralement situé en haut de la fenêtre de l'IDE et comprend
plusieurs menus déroulants, tels que :

• Fichier : Pour créer, ouvrir, enregistrer, et fermer des projets et des fichiers.
• Édition : Pour effectuer des opérations d'édition sur le code, comme couper, copier,
coller et annuler.
• Affichage : Pour gérer l'affichage des différentes fenêtres et outils dans l'IDE.
• Projets : Pour gérer les options spécifiques au projet, telles que les configurations et
les paramètres de construction.
• Outils : Pour accéder à des outils supplémentaires comme les paramètres de
l'environnement de développement.
• Aide : Pour obtenir de l'aide et des informations supplémentaires sur Delphi.

Barre d'Outils (ToolBar) : La Barre d'Outils contient des boutons permettant un accès rapide
aux options les plus populaires du Menu Principal. Elle est généralement située juste en
dessous du Menu Principal et offre des raccourcis pour des actions courantes telles que :

• Exécution : Pour démarrer ou arrêter l'exécution du programme.

• Débogage : Pour activer le mode de débogage et diagnostiquer les problèmes dans le
code.
• Sauvegarde : Pour enregistrer rapidement le projet ou les fichiers ouverts.
• Annuler/Rétablir : Pour annuler ou rétablir des actions effectuées dans l'éditeur de
code.

3.2 Exécution du Programme et Création d'un Nouveau Projet dans Delphi

Exécuter le Programme : Pour exécuter le programme en Delphi, vous avez plusieurs

options :

• Menu Principal : Choisissez l'option "Exécuter" dans le menu déroulant "Exécuter"

du Menu Principal.
• Raccourci Clavier : Appuyez sur la touche F9 pour lancer le programme.
• Barre d'Outils : Cliquez sur le triangle vert dans la Barre d'Outils pour exécuter le
programme.

Créer un Nouveau Programme : Pour commencer à écrire un nouveau programme :

1. Sélectionner "Nouveau" :
o Allez dans le menu "Fichier" du Menu Principal.
o Choisissez l'option "Nouveau" dans la liste déroulante.
2. Choisir un Modèle :
 o Dans la liste ouverte qui apparaît, sélectionnez "VLC Forms Application —
Delphi" pour créer une nouvelle application Windows avec une interface
graphique.

3.3 Disposition des Fenêtres de Delphi

Lors de l'ouverture d'un nouveau projet ou de l'exécution de Delphi, la disposition typique des
fenêtres est la suivante :

1. Fenêtre de Concepteur de Formulaire (Form Designer) :

o C'est la zone principale où vous concevez et disposez visuellement les
éléments de l'interface utilisateur de votre application. Vous pouvez ajouter des
contrôles comme des boutons, des champs de texte, et des menus à partir de la
palette d'outils.
2. Fenêtre de Code (Code Editor) :
o Située souvent en dessous ou à côté de la fenêtre de concepteur de formulaire.
Elle vous permet d'écrire et de modifier le code source de votre application.
3. Fenêtre des Propriétés (Object Inspector) :
o Cette fenêtre est généralement située à droite de la fenêtre de concepteur de
formulaire. Elle vous permet de modifier les propriétés des contrôles
sélectionnés dans le concepteur de formulaire, comme leur taille, leur couleur,
et leurs événements.
4. Fenêtre de Structure (Structure View) :
o Affiche la hiérarchie des contrôles et des composants dans le formulaire,
permettant une navigation rapide entre les différents éléments.
 5. Barre d'Outils (ToolBar) :
o Située en haut, juste en dessous du Menu Principal, elle contient des boutons
pour des actions courantes telles que l'exécution, le débogage, et la sauvegarde.
6. Menu Principal (MainMenu) :
o Situé en haut de la fenêtre de l'IDE, il contient les menus déroulants pour gérer
les fichiers, les projets, et accéder aux fonctionnalités de développement.
7. Fenêtre de Messages (Messages Window) :
o Affiche les messages de débogage, les erreurs, et les avertissements générés
lors de la compilation et de l'exécution du programme.
8. Fenêtre d'Explorateur de Projets (Project Manager) :
o Permet de gérer les fichiers du projet et les unités incluses dans le projet.

3.4 Analyse des Fenêtres de Delphi

Delphi et la Programmation Orientée Objet

Delphi est un langage de programmation orienté objet. Dans ce contexte :

• Objet : Un objet est une entité autonome possédant des propriétés (caractéristiques ou
signes distinctifs) et un ensemble d'actions ou de comportements. Un objet créé peut
être déplacé d'un programme à un autre.

Composants de Delphi
Delphi inclut des centaines d'objets prêts à l'emploi (composants), qui sont présentés dans la
Palette d'Outils (Tool Palette). Ces composants sont regroupés en onglets pour faciliter leur
utilisation.

• Palette d'Outils (Tool Palette) : C'est une fenêtre dans l'IDE où vous trouvez les
composants prêts à l'emploi. Ces composants sont organisés en onglets, chacun
contenant des groupes de composants similaires. Par exemple, vous pourriez avoir des
onglets pour les contrôles visuels (boutons, champs de texte), les composants de base
de données, ou les composants de réseau.
• Onglets de Composants : Chaque onglet regroupe des composants spécifiques en
fonction de leur utilisation. Ces onglets facilitent la recherche et l'ajout de composants
à votre application.

Cette organisation permet de simplifier la conception et la mise en œuvre des applications en

fournissant des outils prêts à l'emploi et faciles à intégrer dans vos projets.

3.5 Onglets Principaux de la Palette d'Outils dans Delphi

Les principaux onglets de la Palette d'Outils (Tool Palette) sont :

1. Standard :
o Contient les éléments d'interface utilisateur standards que la plupart des
programmes utilisent, comme les boutons, les champs de texte, les étiquettes,
et les cases à cocher. C'est l'onglet le plus couramment utilisé pour ajouter des
contrôles de base à votre application.
2. Additional :
o Inclut des composants supplémentaires qui ne sont pas inclus dans les autres
onglets. Ces composants peuvent offrir des fonctionnalités supplémentaires ou
des options plus spécialisées.
3. System :
o Contient des composants liés au système, comme les contrôles pour la gestion
des processus système ou les composants d'interaction avec le système
d'exploitation.
 4. Data Access :
o Regroupe les composants pour accéder et manipuler les données, tels que les
connexions aux bases de données et les composants pour la gestion des
requêtes et des transactions.
5. Data Controls :
o Inclut les contrôles pour afficher et interagir avec les données, comme les
grilles de données, les éditeurs de champs, et les contrôles de navigation dans
les données.
6. Dialogs :
o Contient des composants pour les boîtes de dialogue standard, telles que les
boîtes de dialogue de fichier, les alertes, et les dialogues de confirmation.

Pour commencer, nous travaillerons avec l'onglet Standard de la Palette d'Outils, car il
contient les éléments d'interface utilisateur les plus courants et essentiels pour la plupart des
programmes.

3.6 Fenêtre de Formulaire et Gestion de Projet dans Delphi

Fenêtre de Formulaire (Form Window) :

• La fenêtre de formulaire est un projet pour l'application future. La programmation

visuelle permet de créer des programmes en manipulant des composants et en les
plaçant dans un formulaire.
• Lorsque vous lancez Delphi pour la première fois, il propose automatiquement un
nouveau projet avec une fenêtre de formulaire vide nommée Form1. Ce formulaire
contient tous les éléments de base d'une fenêtre : le titre Form1, les boutons de
réduction, de fermeture et d'agrandissement, ainsi qu'un bouton de menu système de
fenêtre. C'est la fenêtre principale de notre programme où nous ajouterons des
éléments graphiques depuis la Palette d'Outils.

Composants du Formulaire :

• Les zones de texte, les boutons de commande et d'autres contrôles de formulaire sont
appelés composants (Form components) dans Delphi. Dans le programme, le
 formulaire et les composants sont considérés comme des objets. La fenêtre avec les
propriétés des composants est appelée Inspecteur d'Objets (Object Inspector).

Inspecteur d'Objets (Object Inspector) :

• Onglet Propriétés :
o Affiche toutes les propriétés disponibles du composant sélectionné. La colonne
de gauche présente la liste des propriétés, tandis que la colonne de droite
montre les valeurs par défaut actuelles.
• Onglet Événements :
o Affiche les gestionnaires d'événements possibles pour le composant
sélectionné. La colonne de gauche contient les noms des événements, et la
colonne de droite affiche les propriétés ou procédures correspondantes.

Vue de la Structure (Structure View) :

• Affiche tous les objets (composants) placés sur le formulaire.

Arrêter l'Application :

• Cliquer sur le bouton de fermeture de la fenêtre du programme.

• Menu Run > Commande Program Reset (Ctrl+F2).

Enregistrement du Projet :

• Tout programme Delphi comprend un grand nombre de fichiers divers, tels que le
fichier de projet, un ou plusieurs modules, etc. Le fichier de projet est généré
automatiquement par l'environnement Delphi et n'est pas disponible pour une édition
manuelle. Il a une extension unique (.dpr) et n'apparaît pas dans l'Éditeur de Code.
• Enregistrer le Projet : Utilisez la commande Save All. Chaque projet doit être
enregistré dans un dossier séparé. Le dossier du projet et les fichiers associés devraient
être organisés correctement pour éviter toute confusion ou perte de données.

3.7 Nommer et Enregistrer les Fichiers dans Delphi

Nommage des Fichiers :

• Les noms de fichiers doivent être appropriés et ne pas accepter les noms par défaut.
Les noms de fichiers peuvent contenir uniquement des caractères latins. Les chiffres
peuvent être utilisés dans les noms de fichiers à partir du deuxième caractère. Les
autres symboles ne sont pas valides pour le nommage des fichiers.
• Il est important de donner des noms uniques aux fichiers Project1.dpr et Unit1.pas
(ils doivent être différents). Les autres fichiers seront affectés des noms par défaut.
• Lors de la modification des noms de fichiers Project1.dpr et Unit1.pas, suivez la
norme de code Delphi, selon laquelle tous les fichiers doivent avoir un préfixe XXX
— par exemple : prjMyTask1.dpr et untMyTask1.pas (XXX représente les lettres
correspondant au nom abrégé de ce que vous enregistrez : Project1 — prj et Unit1 —
unt). Cette règle s'applique également lors du renommage des composants simples.

Composants Simples dans Delphi

Les composants simples ne sont pas considérés comme plus faciles à utiliser que d'autres
composants, mais ils sont appelés simples car ils sont souvent utilisés dans des combinaisons
complexes avec d'autres composants lors de la création de l'interface utilisateur graphique.

Composants Simples :

• Formulaire (Form) :
o Le formulaire est le seul objet qui n'est pas dans la Palette d'Outils. Un
formulaire est généré automatiquement lorsque vous créez une nouvelle
application. Si vous avez besoin de plusieurs formulaires dans une application,
vous pouvez en ajouter d'autres à votre projet. Nous verrons comment faire
cela plus tard. Lorsque vous travaillez dans Delphi, imaginez que vous êtes un
artiste et que le formulaire est votre toile. Vous "peignez" l'interface utilisateur
graphique de l'application en plaçant des composants sur le formulaire.
Ensuite, en changeant les propriétés des composants, vous modifiez leur
apparence.
• Label (Étiquette) :
o Utilisé pour afficher du texte statique sur le formulaire.
• Text Box (Zone de Texte) :
o Permet à l'utilisateur de saisir du texte.
• Button (Bouton) :
o Permet à l'utilisateur d'effectuer une action lorsqu'il est cliqué.

Propriétés des Composants :

• Les propriétés des composants sont leurs caractéristiques. Cela inclut des éléments tels
que le nom, le texte (caption), la taille ou la couleur du composant.

Examinons certaines propriétés de l'objet Form. Bien que de nombreuses propriétés de

différents composants soient similaires, le Form possède des propriétés uniques.

Propriété Name :

• Nom : Tous les composants doivent avoir une propriété Name, car le nom est
nécessaire pour appeler le composant dans le programme. Il est important de choisir
un nom descriptif pour chaque composant.

Règles de Nommage :

• Utilisez un préfixe pour le nom qui décrit le type de composant. Pour le formulaire
(Form), nous utiliserons le préfixe frm (nom abrégé de Form).

Exemple :

o Si vous voulez appeler un formulaire My, vous devez assigner la valeur

frmMy à la propriété Name du formulaire.

En utilisant des préfixes appropriés pour les noms des composants, vous facilitez
l'organisation et la gestion de votre code, surtout dans des projets plus complexes.
3.8 Examen des Composants Simples :

TLabel :

• TLabel est un composant utilisé pour afficher du texte qui peut être modifié par
l'utilisateur (ou bien par un programme). Voici comment travailler avec les TLabels à
l'aide d'un exemple concret.

Étapes pour Travailler avec TLabel :

1. Créer un Nouveau Projet :

o Lancez Delphi et créez un nouveau projet. Vous devriez voir un formulaire
vierge nommé Form1.
2. Placer un TLabel sur le Formulaire :
o Pour ajouter un TLabel au formulaire, double-cliquez sur l'icône TLabel dans
la Palette d'Outils (Tool Palette).
o Une autre méthode pour placer un TLabel est de faire glisser l'icône TLabel
depuis la Palette d'Outils et de la déposer sur le formulaire.

Après avoir ajouté le TLabel au formulaire, vous pouvez modifier ses propriétés pour
personnaliser le texte affiché, ajuster sa taille, sa couleur, et bien plus encore à l'aide de
l'Inspecteur d'Objets (Object Inspector). Voici quelques propriétés importantes que vous
pourriez vouloir modifier :

• Caption : Le texte qui sera affiché par le TLabel.

• Font : La police du texte.
• Color : La couleur de fond du TLabel.
Voici les étapes pour manipuler le composant TLabel dans Delphi :

1. Créer un Nouveau Projet :

o Lancez Delphi et créez un nouveau projet pour obtenir un formulaire vierge
nommé Form1.
2. Ajouter un TLabel au Formulaire :
o Méthode 1 : Double-cliquez sur l'icône TLabel dans la Palette d'Outils pour
ajouter un TLabel au formulaire.
o Méthode 2 : Cliquez une fois sur l'icône TLabel, puis cliquez à l'endroit
souhaité sur le formulaire. Cette méthode permet de placer le TLabel
directement à l'endroit voulu.
3. Supprimer un TLabel du Formulaire :
o Sélectionnez le TLabel (les petits carrés noirs autour du TLabel indiquent qu'il
est sélectionné) et appuyez sur la touche <Delete>. Pour désélectionner le
TLabel, cliquez n'importe où ailleurs sur le formulaire.
4. Déplacer un TLabel :
o Déplacez le pointeur sur le TLabel, appuyez et maintenez enfoncé le bouton de
la souris pour « saisir » le TLabel. Déplacez le TLabel à l'emplacement désiré
en déplaçant le pointeur, puis relâchez le bouton pour « déposer » le TLabel.
5. Changer la Propriété Name du TLabel :
o Dans l'Inspecteur d'Objets (Object Inspector), cliquez sur la propriété Name et
tapez lblMyLabel. Assurez-vous de modifier la propriété du TLabel et non
celle du Formulaire. Après avoir entré le nouveau nom, enregistrez-le en
appuyant sur la touche <Enter>.
6. Modifier la Caption du TLabel :
o Vérifiez que la Caption du TLabel a changé en lblMyLabel. Modifiez la
Caption en sélectionnant la propriété Caption dans l'Inspecteur d'Objets, tapez
le nouveau texte « It’s my first label ! » et appuyez sur <Enter>. Le nouveau
texte apparaîtra sur le formulaire.
7. Changer la Couleur de Fond du TLabel :
o Sélectionnez la propriété Color, cliquez sur la flèche, choisissez jaune dans la
liste déroulante, et cliquez dessus.
8. Modifier la Police et la Couleur du Texte du TLabel :
o Choisissez la propriété Font et cliquez sur les trois points (ellipse). Dans la
fenêtre de police, changez la police en Arial, le style en Gras Italique et la
taille en 20. Choisissez la couleur rouge dans la liste déroulante et cliquez sur
OK.
9. Ajouter un Autre TLabel :
o Essayez une autre méthode pour ajouter un nouveau TLabel. Cliquez sur
l'icône TLabel dans la Palette d'Outils, déplacez le pointeur vers un endroit du
formulaire, puis cliquez à nouveau. Un nouveau TLabel devrait apparaître.
TEdit :

• TEdit est un composant permettant de stocker du texte qui peut être saisi par
l'utilisateur à la fois lors de la création de l'application et pendant son exécution. Le
texte affiché dans la zone de texte provient de la propriété Text. La propriété
MaxLength définit le nombre maximum de caractères dans la zone de texte. Une
valeur de 0 signifie qu'il n'y a pas de limite sur le nombre de caractères. La police du
texte est définie à l'aide de la propriété Font. Si vous définissez la propriété
ReadOnly à True, l'utilisateur ne pourra pas modifier le texte de TEdit.

Étapes pour Travailler avec TEdit :

1. Créer un Nouveau Projet :

o Lancez Delphi et créez un nouveau projet pour obtenir un formulaire vierge
nommé Form1.
2. Placer un TEdit sur le Formulaire :
o Méthode 1 : Double-cliquez sur l'icône TEdit dans la Palette d'Outils.
o Méthode 2 : Cliquez sur l'icône TEdit, puis cliquez à l'endroit souhaité sur le
formulaire.
3. Changer la Taille de TEdit :
o Placez le pointeur de la souris sur l'un des petits carrés noirs aux coins ou sur
les bords de TEdit. Appuyez et maintenez le bouton gauche de la souris
enfoncé, puis faites glisser le petit carré noir (et la bordure de TEdit avec lui)
dans la direction souhaitée. Lorsque la taille souhaitée est atteinte, relâchez le
bouton.
4. Modifier la Propriété Name de TEdit :
o Dans l'Inspecteur d'Objets (Object Inspector), sélectionnez la propriété Name
et tapez edtInputText. Assurez-vous de modifier la propriété de TEdit et non
celle du formulaire.
5. Modifier la Propriété Text de TEdit :
o Dans l'Inspecteur d'Objets, sélectionnez la propriété Text et tapez un texte par
défaut, par exemple « Entrez votre texte ici ».
6. Définir une Limite de Caractères :
o Modifiez la propriété MaxLength en entrant un nombre entier, par exemple
20, pour limiter le nombre de caractères que l'utilisateur peut entrer.
7. Changer la Police du Texte :
o Sélectionnez la propriété Font et cliquez sur les trois points (ellipse). Dans la
fenêtre de police, choisissez une police, un style et une taille pour le texte, puis
cliquez sur OK.
8. Rendre TEdit en Lecture Seule :
o Modifiez la propriété ReadOnly en la définissant sur True pour que
l'utilisateur ne puisse pas modifier le texte dans TEdit.

Exécution du Programme :

9. Modifier les Propriétés du Formulaire :

o Sélectionnez le formulaire en cliquant n'importe où en dehors des TLabels ou
en choisissant Form1 dans la Vue de Structure (Structure View). Changez les
propriétés du formulaire comme suit :
▪ Name : frmLabelExample
 ▪ Caption : Example of Label
10. Exécuter le Programme :
o Cliquez sur l'icône d'exécution (triangle vert), choisissez la commande Run
dans le menu Run, ou appuyez sur la touche <F9> pour lancer l'application.
11. Quitter l'Application :
o Cliquez sur le bouton X en haut à droite du formulaire pour fermer
l'application.

• Rendre TEdit en Lecture Seule :

• Modifiez la propriété ReadOnly en la définissant sur True. Cela empêchera

l'utilisateur de modifier le texte dans TEdit.

• Tester le Mode Lecture Seule :

• Appuyez sur <F9> pour exécuter à nouveau l'application. Essayez de modifier le texte
: vous verrez qu'il est désormais impossible de le changer. Bien que cela puisse
sembler inutile, le mode lecture seule peut être très utile dans certains scénarios où
vous souhaitez afficher des informations sans permettre à l'utilisateur de les modifier.

TButton

Le TButton est généralement utilisé pour démarrer l'exécution d'une partie du code ou de
l'ensemble du programme. En d'autres termes, en cliquant sur le contrôle TButton,
l'utilisateur incite le programme à effectuer une certaine action. À ce moment-là, le bouton
change d'apparence comme s'il était enfoncé.

Vous pouvez attribuer des combinaisons de touches de raccourci aux boutons. Pendant
l'exécution, appuyer sur ces touches de raccourci équivaut à utiliser un clic gauche de la souris
sur le bouton.

Effectuer un ensemble d'actions :

1. Créez un nouveau projet.

2. Dans l'Object Inspector, changez la propriété Name de la forme en
frmButtonExample et Caption en "Button Example".
3. Placez le bouton sur la forme. Double-cliquez sur l'icône TButton dans la Tool
Palette, ou cliquez sur son icône puis cliquez n'importe où sur la forme. Changez la
propriété TButton en btnMyButton. Cliquez sur la propriété Name dans l'Object
Inspector et tapez btnMyButton. Assurez-vous de changer la propriété TButton, et
non la forme. Dans la Structure View, vous verrez Button1: TButton (dès que vous
changez le nom, btnMyButton: TButton apparaîtra).
4. Changez la propriété Caption en &Run. Notez que la lettre suivant & est soulignée
(dans ce cas, c'est R).
5. Changez la taille et l'emplacement du bouton.
6. Appuyez sur <F9> pour exécuter l'application.
7. Cliquez sur le bouton. Le bouton semble enfoncé.
8. Activez le bouton en appuyant sur la touche <R>. Comme vous pouvez le voir, le
bouton ne semble pas enfoncé lorsque vous l'activez avec la touche de raccourci.
 Cependant, puisque aucun code n'est connecté au bouton, nous ne voyons aucune
réaction du bouton. Néanmoins, vous pouvez croire qu'il est activé.

9. Cliquez sur le bouton X en haut à droite de la forme pour quitter l'application.

La légende de btnMyButton apparaît comme Run, et non pas Run. Placer le symbole & avant
n'importe quel caractère de la propriété Caption attribue une touche de raccourci au bouton.
Dans la légende du bouton, le caractère suivant & est souligné. Cela indique aux utilisateurs
qu'une touche de raccourci est associée au bouton. Les utilisateurs peuvent activer le bouton
depuis le clavier en appuyant sur Alt et la touche avec la lettre soulignée.

Que faire si la légende elle-même doit contenir & ? En effet, si vous l'incluez dans la légende,
cela souligne la lettre suivante et le & lui-même n'est pas visible. Pour résoudre ce problème,
utilisez la règle suivante : le symbole & apparaîtra dans la légende si la propriété Caption
contient deux & ensemble, c'est-à-dire &&. Par exemple, pour créer la légende "This & That",
vous devez écrire "This && That" dans la propriété Caption. Les combinaisons de touches de
raccourci ne sont pas attribuées dans ce cas.

Comme vous pouvez le voir, dans Delphi, vous pouvez créer une forme (et une application)
simple en une minute. Les interfaces utilisateur graphiques les plus compliquées peuvent être
créées de la même manière.

Vous êtes maintenant familiarisé avec les propriétés des composants Delphi les plus
populaires : formes, labels, zones de saisie et boutons. Pour améliorer vos nouvelles
connaissances, expérimentez avec ces composants. Essayez de modifier leurs autres
propriétés.

Gestion d'un Événement de Pression de Bouton

Les composants visuels sont capables de générer et de gérer plusieurs dizaines de types
d'événements : clics de souris, pressions de boutons, pressions de touches du clavier,
ouvertures de fenêtres, etc.

Lorsque l'utilisateur appuie sur un bouton de la souris, Windows envoie un message « Ce

bouton de souris a été cliqué » à l'application. Le programme répondra à cet événement si un
programmeur a prévu une réaction à celui-ci.

La réponse à un événement est le résultat d'un événement système se produisant.

La réponse d'un programme à un événement est programmée sous forme d'une liste d'actions
à effectuer ; cette liste est saisie dans une fenêtre de l'Éditeur de Code. Pour qu'un programme
réagisse à un clic de souris, il est nécessaire d'écrire un fragment de programme appelé
gestionnaire d'événements.

3.9 Fenêtre de l'Éditeur de Code

Cette fenêtre porte le titre Unit1 au départ.

Vous pouvez ouvrir plusieurs fichiers de code source dans la fenêtre de l'éditeur. Tous les
fichiers ouverts occupent leurs propres onglets, et leurs étiquettes d'onglets afficheront les
noms des fichiers source. Il y aura trois unités si le programme a trois fenêtres. Les trois
unités seront affichées dans l'Éditeur de Code source.

Les événements simples contiennent uniquement la source de l'événement, indiquée par le

paramètre Sender dans la procédure du gestionnaire d'événements. Les procédures de gestion
des événements pour les événements complexes nécessitent des paramètres supplémentaires
tels que les coordonnées du pointeur de la souris.

La sélection d'un élément de contrôle génère un événement OnClick, également appelé

événement de pression. En général, il provient d'un clic de souris sur un composant.
L'événement OnClick est l'un des événements les plus fréquemment utilisés dans le
développement d'une application. Pour certains composants, l'événement OnClick peut
provenir de différentes actions sur l'élément de contrôle.

À titre d'exemple, nous allons écrire le gestionnaire d'événements de pression pour le bouton
de commande btnMy, placé sur la forme frmMy :

Double-cliquez sur ce bouton.

Delphi génère automatiquement le code pour minimiser la saisie au clavier, en fournissant le

corps complet de la procédure de pression du bouton de souris.

Nous pouvons trouver la propriété ou la méthode appropriée en parcourant la liste. Comme la

liste est relativement grande, nous pouvons accélérer la recherche en entrant quelques caractères
du nom, ce qui réduira considérablement le nombre d'éléments dans la liste.
Nous terminons l'entrée de complétion de code en appuyant sur Entrée.

Le code final pour la réponse à la pression du bouton de commande btnMy ressemble à ce qui
suit :

Le programme se terminera si vous appuyez sur le bouton de commande btnMy après que le
programme ait été lancé. Dans cet exemple, nous avons utilisé la méthode (procédure) Close.
Appeler une méthode indique ce qui sera fait avec le composant. Vous pouvez voir une
référence de méthode dans l'exemple : le nom du composant apparaît en premier, suivi d'un
délimiteur (point) et enfin du nom de la méthode spécifiée après le délimiteur.

Chaque composant a son propre ensemble de méthodes. Parfois, des méthodes identiques
peuvent être trouvées dans différents composants.

Démontrons une autre méthode, Clear. Cette méthode efface le contenu et peut être
appliquée, par exemple, au composant Edit.

Comme mentionné précédemment, les composants ont des méthodes et des propriétés.
Les propriétés sont des attributs des composants. Les propriétés peuvent être modifiées ou
spécifiées comme suit : d'abord, nous faisons référence au nom du composant, puis nous
mettons le délimiteur (point), et après le délimiteur, nous spécifions le nom de la propriété
(Delphi nous permet de choisir une propriété dans la liste de complétion du code). Ensuite, nous
mettons l'opérateur d'affectation et, enfin, nous spécifions la valeur de la propriété.

La plupart des propriétés des composants correspondent à celles affichées dans la fenêtre de
l'Inspecteur d'Objets. Il y a aussi certaines propriétés qui ne sont pas reflétées là ; nous les
examinerons plus tard. Pour l'instant, écrivons un programme dans lequel la pression sur le
bouton de commande remplira la fenêtre de la forme avec un fond blanc. Dans ce programme,
nous devons utiliser une propriété Color.

Non seulement nous pouvons spécifier les propriétés des composants, mais nous pouvons
également les lire. Un exemple d'utilisation de cette capacité est d'assigner la valeur d'une
propriété d'un composant à une propriété d'un autre composant. La syntaxe ressemble à ceci :

Par exemple :
Cela indique au programme de mettre le texte de la zone de texte edtMy dans la légende du
label lblMy.

Les actions multiples sont séparées par un point-virgule.

Par exemple :

Deux actions seront effectuées après que le bouton soit pressé : la zone de texte sera effacée et
son fond sera rempli de bleu.

3.10 Variables et Types de Variables. Conversion de Type

Pour calculer une valeur pour une seule expression avec des entrées données, et le faire une
seule fois, il n'est pas nécessaire d'écrire un programme complet. Cependant, si le processus
de calcul doit être effectué fréquemment et avec des entrées différentes à chaque fois, il est
pertinent d'automatiser ce processus.

Opérateur d'Affectation
Si vous souhaitez convertir des degrés (DEGR) en radians (RAD), la formule de conversion
en Delphi sera la suivante :
L'opérateur d'affectation est une instruction très basique et importante dans tout langage de
programmation. Il assigne une valeur d'une expression calculée du côté droit du symbole
d'affectation := à une variable du côté gauche du symbole d'affectation. Le symbole
d'affectation se compose de deux symboles séparés (: et =) ; cependant, il est interprété en
Delphi comme un seul élément.

Le fonctionnement interne est tel que la valeur de l'expression à droite de l'opérateur

d'affectation est d'abord calculée, puis cette valeur résultante est assignée à la variable à
gauche de l'opérateur d'affectation.

Le format de l'opérateur d'affectation est le suivant :

Maintenant, parlons des variables. Une variable est un emplacement en mémoire qui a un
nom. La taille de la mémoire allouée pour une variable dépend de La taille de la mémoire à
écrire dépend de la valeur à y inscrire. En théorie, il serait possible d'allouer uniquement de
grands "emplacements" de mémoire pour toutes les variables. Cependant, si tel était le cas,
nous manquerions rapidement de mémoire disponible.

Pour savoir exactement combien de mémoire allouer pour une variable, nous devons connaître
son type de données.

Vous pouvez utiliser des variables en Delphi pour une variété de tâches et de raisons. Les
variables doivent être définies avant de pouvoir être utilisées. Le mot-clé var est utilisé pour
commencer une section de définitions de variables, qui est située après la définition de la
procédure et avant le mot-clé begin. Le format de définition des variables est le suivant :
Un nom de variable est une séquence de caractères avec la syntaxe suivante :

• Peut contenir des lettres, des chiffres (0–9) ou des underscores (_);
• Doit commencer par une lettre.

Le nom de la variable peut être de n'importe quelle longueur (le nombre de caractères n'est
pas limité) et n'est pas sensible à la casse.

Lorsque vous pensez à nommer une variable, notez qu'il est préférable d'éviter les noms à un
caractère sauf pour les variables temporaires ou les compteurs de boucle. Les variables de
compteur de boucle sont les noms I et J. D'autres instances de noms de variables à un
caractère sont S (chaîne de caractères) ou R (rayon). Les noms de variables à un caractère
doivent toujours être en majuscules, mais il est toujours préférable d'utiliser des noms plus
significatifs. Il est recommandé de ne pas utiliser la lettre l comme nom de variable pour
éviter la confusion avec le chiffre 1.

Exemple :

Dans cet exemple, une variable k de type Integer est déclarée. Il existe de nombreux types
de données en Delphi. Examinons quelques-uns d'entre eux.

Les entiers peuvent être décrits avec les types de données suivants :
Nous utiliserons principalement Integer tout au long de ce livre.

Les nombres réels peuvent également être représentés par différents types de données. Nous
utiliserons le type de donnée Real.

Vous connaissez la notation scientifique normalisée (également appelée notation

exponentielle) pour la représentation des nombres réels. Par exemple :

• 3,28 × 10^17
• 1,4 × 10^-9
• -5,101 × 10^4
En Delphi, ces nombres sont enregistrés comme suit :

• 3,28e+17
• 1,4e-09
• -5,101e+4
• 328e15
• 0,14e-8
• -5101e+1
• 0,328e+18
• 140e-11
• -510100e-1

3.11 Expressions Arithmétiques

Revenons sur les opérateurs d'assignation. Le type de données à gauche doit correspondre au
type de données de la valeur de l'expression arithmétique à droite.

Une expression arithmétique est une expression mathématique légale construite à l'aide de
constantes, variables, fonctions, opérateurs arithmétiques (tels que +, *, -, / et exponentiation)
et parenthèses, (et).

Opérateurs utilisés dans les expressions arithmétiques :

Exemples :

• 13 div 4 = 3
• 13 mod 4 = 1
• -13 div 4 = -3
• -13 mod 4 = -1
13 div –4 = –3
13 mod –4 = 1
-13 div –4 = 3
-13 mod –4 = –1
0 div 2 = 0
1 mod 2 = 1
2 div 5 = 0
2 mod 5 = 2

Si la valeur de l'expression est un entier, elle peut être assignée à une variable de type Réel,
mais l'inverse n'est pas possible.

3.11.1 Ajouter Deux Nombres

Créez un formulaire frmCalc avec deux zones de texte TEdit nommées edtA et edtB, un
bouton btnAdd et une étiquette lblResult.

Définissez la propriété Caption du bouton et laissez les propriétés Text des zones de texte
vides. Double-cliquez sur le bouton pour ouvrir la fenêtre de code et commencer à coder le
gestionnaire d'événement de clic du bouton.

Tout d'abord, nous allons déclarer les variables :

Nous allons obtenir les valeurs de a et b à partir des zones de texte edtA et edtB respectivement.
Notez que nous entrons des valeurs de type chaîne dans les zones de texte, nous devons donc
les convertir en type numérique. Nous utiliserons la fonction StrToFloat pour cela.
Le résultat de l'ajout de deux variables est stocké dans une troisième variable (c), puis ce résultat
est converti de nouveau en chaîne en utilisant FloatToStr (nombre) et affiché dans l'étiquette
lblResult. Pour rendre le code encore plus élégant, nous pouvons l'écrire comme suit :

Lors de l'utilisation des fonctions StrToFloat et FloatToStr dans Delphi, il est important de
veiller à la bonne mise en forme du séparateur décimal. Dans le programme (unité), seule la
période (« . ») est autorisée comme séparateur décimal. Cependant, dans les fenêtres de saisie
et de sortie du formulaire, le séparateur décimal dépend des paramètres régionaux de
Windows. Par exemple, dans de nombreux pays européens, la virgule est utilisée pour séparer
les parties entière et fractionnaire d'un nombre décimal.

Les fonctions IntToStr (entier) et StrToInt (chaîne) sont utilisées pour convertir des
entiers en chaînes et des chaînes en entiers respectivement.
• ROUND(X) est utilisé pour arrondir un nombre réel au nombre entier le plus proche. Les
nombres avec une partie fractionnaire égale à .5 sont arrondis au nombre pair le plus proche.

• TRUNC(X) retourne simplement la partie entière d'un nombre réel, en supprimant la partie
fractionnaire sans arrondir.

• INT(X) fonctionne de manière similaire à TRUNC, mais retourne le résultat en format

REAL.
3.11.2 Expressions Logiques et Variables Booléennes

Les expressions logiques, aussi appelées expressions booléennes, sont des expressions qui
évaluent à TRUE (VRAI) ou FALSE (FAUX). Ces expressions sont fondamentales en
programmation pour la prise de décision et le contrôle du flux d'exécution. En Delphi, les
variables booléennes sont déclarées avec le type Boolean.

3.11.2.1 Exemple de Déclaration de Variable Booléenne

3.11.3 Opérateurs Relationnels

Les opérateurs relationnels sont utilisés pour comparer deux valeurs et retourner un résultat
booléen (TRUE ou FALSE). Voici les principaux opérateurs relationnels en Delphi :

• = : Égal à
o Exemple : 5 = 5 est TRUE.
• <> : Différent de
o Exemple : 5 <> 3 est TRUE.
• < : Moins que
o Exemple : 5 < 10 est TRUE.
• <= : Moins que ou égal à
o Exemple : 5 <= 5 est TRUE.
• > : Plus grand que
o Exemple : 10 > 5 est TRUE.
• >= : Plus grand que ou égal à
o Exemple : 5 >= 5 est TRUE.

3.11.3.1 Exemples d'Expressions Logiques

Voici quelques exemples d'expressions logiques utilisant les opérateurs relationnels :

3.11.4 Opérateurs Logiques

Les opérateurs logiques permettent de combiner plusieurs expressions booléennes. En Delphi,

vous avez :

• AND : Conjonction logique

o Exemple : TRUE AND FALSE est FALSE.
• OR : Disjonction logique
o Exemple : TRUE OR FALSE est TRUE.
• NOT : Négation logique
o Exemple : NOT TRUE est FALSE.
• XOR : Disjonction exclusive
o Exemple : TRUE XOR FALSE est TRUE.

3.11.4.1 Exemples d'Opérateurs Logiques

Les expressions logiques sont très utiles pour les conditions et les boucles dans la
programmation, permettant de créer des flux de contrôle dynamiques basés sur des critères
spécifiés.

3.11.5 Opérateurs Logiques et Valeurs Logiques

Les opérateurs logiques en Delphi sont utilisés pour manipuler des valeurs booléennes (TRUE
ou FALSE). Ils permettent de combiner ou de modifier des expressions booléennes.

3.11.5.1 Opérateurs Logiques

1. NOT : Négation logique

o Inverse la valeur booléenne.
o Exemple : NOT TRUE est FALSE.
2. AND : Conjonction logique
o Retourne TRUE uniquement si les deux opérandes sont TRUE.
o Exemple : TRUE AND FALSE est FALSE.
3. OR : Disjonction logique
o Retourne TRUE si au moins un des opérandes est TRUE.
o Exemple : TRUE OR FALSE est TRUE.
4. XOR : Disjonction exclusive
o Retourne TRUE si exactement un des opérandes est TRUE.
o Exemple : TRUE XOR FALSE est TRUE.

3.11.5.2 Exemple d'Utilisation des Opérateurs Logiques

3.11.5.3 Table des Valeurs Logiques

Voici comment les opérateurs logiques interagissent avec les valeurs booléennes :
3.11.5.4 Ordre de Précédence des Opérateurs

Les opérateurs logiques sont évalués selon un ordre de priorité. Voici la table de priorité des
opérateurs logiques :

1. NOT : Négation (plus haute priorité)

2. AND : Conjonction
3. OR : Disjonction (plus basse priorité)

Lorsque plusieurs opérateurs logiques sont utilisés dans une expression, les opérations sont
effectuées selon cet ordre de priorité. Les opérations avec des opérateurs ayant une priorité
plus élevée sont effectuées avant celles avec des opérateurs ayant une priorité plus basse.

3.11.5.5 Exemple avec Précédence des Opérateurs

Ce code retourne TRUE car NOT A est FALSE, mais B AND C est FALSE, et FALSE OR FALSE est
toujours FALSE, alors que NOT A est FALSE mais B AND C est FALSE.

En Delphi, les expressions sont évaluées en suivant une certaine priorité des opérateurs. Voici
un résumé de l'ordre d'évaluation des opérateurs :

1. Parenthèses () : Les expressions entre parenthèses sont évaluées en premier.

2. Évaluation des fonctions : Les fonctions sont évaluées après les expressions entre
parenthèses.
3. Opérateurs unaires : NOT, et le signe uniaire - sont évalués ensuite.
4. Opérateurs multiplicatifs : Multiplication *, division /, division entière div, et le
reste mod sont évalués après les opérateurs unaires.
5. Opérateurs additifs : Addition + et soustraction - sont évalués après les opérateurs
multiplicatifs.
6. Opérateurs relationnels : Égalité =, inégalité <>, infériorité <, supériorité >,
infériorité ou égalité <=, et supériorité ou égalité >= sont évalués ensuite.
7. Opérateurs logiques : AND, OR, XOR sont évalués en dernier.
Exemple d'Évaluation
Examinons l'expression suivante en utilisant les valeurs données :

1. Substituer les valeurs dans l'expression :

2. Évaluer les parenthèses :

3. Évaluer les opérateurs multiplicatifs :

• 4 > 4 est false
• 6 = 7 est false
• 3 <= 3 est true

L'expression devient :

4. Évaluer les opérateurs unaires :

• not false est true
L'expression devient :

5. Évaluer les opérateurs logiques :

• Les opérateurs and ont une priorité plus élevée que or, donc nous évaluons
true and true d'abord, ce qui donne true.

L'expression devient :

6. Évaluer l'opérateur or :
• false or true est true.
Conclusion

La valeur finale de l'expression est true.

3.12 Structure des Instructions Conditionnelles en Delphi

Les instructions conditionnelles permettent d'exécuter des blocs de code en fonction de

certaines conditions. En Delphi, les instructions conditionnelles courantes sont les
IF...THEN...ELSE. Elles permettent de contrôler le flux d'exécution de votre programme en
fonction des valeurs de certaines variables ou expressions.

3.12.1.1 Syntaxe de Base

La syntaxe générale d'une instruction IF...THEN...ELSE est :

• condition : Une expression qui renvoie un résultat de type Boolean (TRUE ou

FALSE).
• action1 : Bloc de code exécuté si la condition est TRUE.
• action2 : Bloc de code exécuté si la condition est FALSE.

3.12.1.2 Exemple Simple

Voici un exemple de code Delphi utilisant une instruction IF...THEN...ELSE :

Dans cet exemple :

• La température est lue à partir d'un composant TEdit et convertie en entier.

• Si la température est inférieure à 10, le texte du TLabel affiche "Mettez un manteau".
• Sinon, le texte du TLabel affiche "Mettez une cape".

3.12.1.3 Structure Conditionnelle Complexe

Vous pouvez également imbriquer des instructions IF...THEN...ELSE pour créer des
structures conditionnelles plus complexes :

Dans cet exemple :

• Les scores sont classés en différentes catégories (Excellent, Très Bien, Bien, Suffisant)
selon leur valeur.
• Les instructions ELSE IF permettent de vérifier plusieurs conditions de manière
séquentielle.

3.12.1.4 Diagramme de Flux (Flowchart)

Pour visualiser le processus décisionnel, vous pouvez créer un diagramme de flux :

1. Début
2. Lire la température
3. Condition : Température < 10 ?
o Oui : Afficher "Mettez un manteau"
o Non : Afficher "Mettez une cape"
4. Fin
Le diagramme de flux aide à comprendre comment les décisions sont prises dans le
programme et quel bloc de code sera exécuté en fonction des conditions spécifiées.

Voici un exemple complet utilisant l'instruction If...Then...Else pour déterminer la valeur

maximale entre deux nombres entiers en Delphi :

Exemple : Trouver la Valeur Maximale

3.12.1.5 Description

Nous avons deux nombres entiers donnés, et nous souhaitons trouver et afficher le maximum
de ces deux nombres.

3.12.1.6 Code Delphi

3.12.1.7 Explication

1. Lecture des Valeurs :

o a et b sont définis comme des entiers et leurs valeurs sont lues depuis les
champs de texte edtA et edtB, respectivement. La fonction StrToInt est
utilisée pour convertir les chaînes de caractères en entiers.
2. Condition If...Then...Else :
o if a > b then : Cette condition vérifie si a est supérieur à b.
▪ Si la condition est vraie (a est effectivement supérieur à b), alors m
reçoit la valeur de a.
▪ Sinon (a n'est pas supérieur à b), m reçoit la valeur de b.
 3. Affichage du Résultat :
o La valeur maximale est convertie en chaîne avec IntToStr et affichée dans le
label lblResult.

Ce code utilise une structure conditionnelle simple pour comparer deux valeurs et afficher la
valeur maximale en fonction du résultat de la comparaison.

Pour structurer un bloc If...Then...Else avec une instruction imbriquée en Delphi, vous
pouvez utiliser une combinaison de conditions et d'instructions begin...end pour regrouper
plusieurs déclarations. Voici un exemple de ce à quoi cela pourrait ressembler :

Exemple : Instructions Imbriquées avec If...Then...Else

3.12.1.8 Description

Supposons que nous voulons vérifier deux conditions successives et exécuter différentes
séries d'instructions en fonction de ces conditions.

3.12.1.9 Code Delphi

3.12.1.10 Explication

1. Lecture des Valeurs :

o Les variables a et b sont définies comme des entiers et sont assignées à partir
des champs de texte edtA et edtB.
2. Première Condition :
o if a > 10 then : Vérifie si a est supérieur à 10. Si c'est vrai, le bloc
begin...end associé s'exécute.
3. Deuxième Condition Imbriquée :
o À l'intérieur du bloc de la première condition, une autre condition if b < 5
then est vérifiée.
o Si b est inférieur à 5, le bloc begin...end de cette deuxième condition est
exécuté, affichant deux messages.
4. Instructions Alternatives :
o Si la première condition a > 10 n'est pas remplie, le bloc else est exécuté,
affichant un message différent.

Ce code montre comment imbriquer des conditions If...Then pour exécuter des blocs
d'instructions selon les résultats de plusieurs tests logiques.

3.13 Procédures

Il n'est pas suffisant de connaître les opérateurs d'un langage de programmation pour écrire
des programmes facilement, rapidement et avec peu d'erreurs. Il est nécessaire de maîtriser les
compétences et les principes de la programmation structurée ou procédurale.

L'application pratique de ces principes permet de :

• Écrire des programmes facilement

 • Créer des programmes compréhensibles et lisibles
• Trouver les erreurs dans les programmes plus rapidement
• Modifier et améliorer les programmes plus rapidement

Un des principes principaux de la programmation structurée est appelé programmation

descendante. Ce principe stipule que la tâche principale d'un programme doit être décomposée
en plusieurs sous-tâches. Ensuite, chaque sous-tâche doit être décomposée en sous-tâches
encore plus simples et ce processus doit se poursuivre jusqu'à obtenir un ensemble de petites
tâches simples à implémenter.

Les sous-tâches séparées sont appelées procédures en Delphi.

Exemple : Résolution d'une équation quadratique

1. Créer un nouveau formulaire :

o Nommer le formulaire frmQuadEq.
o Définir la propriété Caption du formulaire sur "Solution of quadratic
equation".
2. Ajouter des contrôles au formulaire :
o Ajouter trois zones de texte (TEdit) que vous appellerez edtA, edtB et edtC.
Ces zones de texte permettront à l'utilisateur d'entrer les valeurs des
coefficients AAA, BBB et CCC de l'équation quadratique.
o Ajouter un label (TLabel) au-dessus des zones de texte pour indiquer à
l'utilisateur ce qu'il doit entrer. Définir la propriété Caption du label sur "Enter
coefficients of quadratic equation".
o Ajouter un bouton (TButton) nommé btnSolve avec la propriété Caption
définie sur "Solve".
3. Créer une procédure pour résoudre l'équation quadratique :
Créer une procédure pour gérer l'événement du bouton :

3.14 Fonctions

Voyons maintenant les fonctions. Les fonctions sont similaires aux procédures, sauf qu'elles
retournent une valeur en plus d'exécuter des instructions.

Delphi propose de nombreuses fonctions intégrées, mais il y a des situations où vous devez
écrire vos propres fonctions. Par exemple, si vous devez résoudre une tâche en utilisant la
fonction tangente Tg(A) plusieurs fois, mais qu'il n'existe pas de fonction intégrée pour cela,
vous pouvez créer votre propre fonction. Voici un exemple simple :

3.14.1.1 Exemple : Calculer un autre côté d'un triangle rectangle

Considérons un triangle rectangle. L'angle (en degrés) et la longueur du côté adjacent sont
donnés. Nous voulons calculer la longueur de l'autre côté.
 1. Créer une nouvelle fonction :
o Double-cliquez sur le bouton pour ouvrir l'éditeur de code.
2. Définir la procédure du bouton :

Créer une fonction personnalisée (si nécessaire) :

Si vous avez besoin de créer une fonction pour calculer la tangente en degrés, vous pouvez le
faire ainsi :

Utiliser la fonction dans votre code :

Remplacez Tan(alfa * Pi / 180) par Tg(alfa) dans la procédure du bouton :

3.14.2 Déclaration des Fonctions

Lorsque vous déclarez une fonction, vous spécifiez son nom, le nombre et le type des
paramètres qu'elle prend, ainsi que le type de sa valeur de retour.

3.14.2.1 Exemple de Déclaration de Fonction :

• Nom : Tg
• Paramètres : Degrees (type Real)
• Type de retour : Real
Format de Déclaration de Fonction

Voici le format de déclaration d'une fonction en Delphi :

Exemple : Fonction tg pour calculer la tangente

• Nom de la Fonction : tg
• Paramètre : x (type Real)
• Type de Retour : Real

Notes :

• La fonction doit avoir au moins une instruction d'assignation qui assigne une valeur au
nom de la fonction (tg dans ce cas).
• Les variables locales (comme y ici) sont déclarées à l'intérieur de la fonction.
• Les paramètres peuvent être de valeur ou variables, régis par les mêmes règles que les
paramètres de procédure.

3.14.3 Boucles

Une boucle est une séquence d'instructions exécutée de manière répétée. Il existe deux types
de boucles : la boucle avec une précondition (While…do…) et la boucle avec une post-
condition (Repeat…Until…).

3.14.3.1 Boucle avec Précondition : While…do…

En Delphi, la syntaxe de la boucle While…do… est la suivante :

La boucle While…do… exécute l'instruction de manière répétée tant que l'expression
conditionnelle est True.

Points à noter :

• L'expression conditionnelle est évaluée avant l'exécution de l'instruction.

• Si la valeur de l'expression est False dès le début, l'instruction ne sera pas exécutée du
tout.
• Si vous devez exécuter plusieurs instructions, utilisez begin…end après do :

Exemple :

Dans cet exemple, le message affichera les nombres de 1 à 10. La condition i <= 10 est vérifiée
avant chaque itération, et les instructions dans begin…end sont exécutées tant que la condition
est vraie.