Cours LAZARUS, tutoriel & guide de travaux pratiques en pdf.

Affectation

Entrées-sorties

Dans la suite nous allons transformer notre premier programme pour qu’il produise un autre effet-net. Les instructions que nous allons y ajouter vont toutes se placer entre begin et end.
Les instructions write et writeln (identique à write mais suivi d’un saut à la ligne) permettent d’afficher des données à l’écran. Ces instructions sont suivies d’un point-virgule comme presque toute instruction Lazarus/FreePascal.
Exemples :
writeln(4785); {affiche le nombre 4785}
writeln(47.85); {affiche le nombre décimal 47,85 (point décimal !!!)}
writeln(′Lazarus′); {affiche la chaîne de caractères « Lazarus »}
Retenons ici la règle de syntaxe importante :
Chaque instruction se termine par un point-virgule « ; ».
Devant end on peut laisser de côté le point-virgule.
Rappelons qu’il faut terminer par l’instruction readln qui fait attendre le programme jusqu’à ce que l’utilisateur appuie sur la touche « enter ». Cela est nécessaire 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(′lazarus′);
readln;
end.
Si nous exécutons le programme maintenant, l’affichage est le suivant :
4785
4.78500000000000E+0001
lazarus
L’affichage de 4.78500000000000E+0001 peut surprendre. Lazarus/FreePascal utilise d’office une écriture lourde mais précise du nombre 47.85. Il le transforme en notation scientifique. Il faut donc
lire : 4.785 ⋅101 .
L’instruction writeln permet de formater l’affichage de la façon suivante :
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 }
Exercice :
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.

Lazarus permet d’effecteur non seulement les opérations arithmétiques mais toutes les opérations mathématiques usuelles.
+ est le signe de l’addition, – celui de la soustraction,
* celui de la multiplication et / représente une division.
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és par des parenthèses. Lazarus/FreePascal 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.
Exemples : 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. Remarquez que les parenthèses sont obligatoires.
Exercice 2-2
Effectuez (sans l’aide de 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 à Lazarus/FreePascal.
Lazarus/FreePascal 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

Chaque variable possède un type précis.
Dans la suite nous utiliserons 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 et un nombre du type real représente un nombre appelé décimal en mathématiques.
Chaque langage de programmation impose des contraintes aux nombres.
En Lazarus/FreePascal un nombre de type real est représenté par un nombre en virgule flottante (« floating point »). C’est une notation scientifique où la mantisse peut avoir jusqu’à 15 chiffres décimaux significatifs et où 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 Lazarus/FreePascal 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 une apostrophe, alors il faut en mettre deux de suite, sinon Lazarus/FreePascal pense que cette apostrophe termine la chaîne. Ainsi l’expression
« l’ordinateur » s’écrit ‘l »ordinateur’ en Lazarus/FreePascal. Il ne faut surtout pas mettre de guillemets anglais «  » » comme on a l’habitude de les mettre dans un texte.
Lorsque Lazarus affiche un caractère ou une chaîne de caractères par une instruction write ou writeln les apostrophes au début et à la fin sont omises. De même, une double apostrophe à l’intérieur d’une chaîne est affichée 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 (« ; »).
Ces déclarations se trouvent avant le bloc begin … end.
Exemple :
program Project1;
{$mode objfpc}{$H+}
uses
{$IFDEF UNIX}{$IFDEF UseCThreads}
cthreads,
{$ENDIF}{$ENDIF}
Classes
{ you can add units after this };
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′;
Lazarus/FreePascal 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; writeln(nombre+2);
la valeur 6 est affectée à la variable nombre afficher nombre+2, c’est-à-dire afficher 8.
L’expression de droite peut aussi contenir 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. L’effet de l’instruction est donc nombre:=8;
writeln(nombre); 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.

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 Exercices
2.10 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 Exercices
4.6 Un algorithme efficace
4.7 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 Lazarus
7.1 Introduction
7.2 Les fichiers utilisés en Lazarus
7.3 L’approche Orientée-Objet
7.4 Passage FreePascal – Lazarus – 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