Programmation Informatique

Chapitre I : Généralités

I.1 Définition du langage pascal :

Ce langage a été créé en 1969 à l’école polytechnique de ZURICH par N. WIRTH. Il a été conçu pour permettre d’enseigner la programmation comme une science. Le Pascal est le langage de développement le plus utilisé pour l’enseignement, et un des plus utilisé en programmation professionnelle sur micro-ordinateur.

I.2 Structure d’un programme :

Program nom de programme ;

Const déclaration de constantes ;

Function déclaration de fonction ;

Procedure déclaration de procédure paramétrée ou procédure simple ;

Var déclaration de variables ;

 

BEGIN

…

Commandes

…

END.

I.3 Grammaire du Pascal

  • Un nom de programme respecte les règles liées aux identificateurs (cf plus bas) et ne peut pas contenir le caractère point « . »
  • Un programme principal débute toujours par BEGIN et se termine par END. (avec un point). Alors qu’un sous-programme (ou fonction, procédure, bloc conditionnel…) commence lui aussi par Begin mais se termine par End ; (sans point mais avec un point-virgule).
  • Chaque commande doit se terminer avec un point-virgule. Il n’y a pas d’exception à la règle hormis Begin et l’instruction précédent End ou Else.
  • Il est toléré de mettre plusieurs instructions les unes à la suite des autres sur une même ligne du fichier mais il est recommandé de n’en écrire qu’une par ligne : c’est plus clair et en cas de bogue, on s’y retrouve plus aisément. De plus, s’il vous arrive d’écrire une ligne trop longue, le compilateur vous le signifiera en l’erreur Error 11: Line too long. Il vous faudra alors effectuer des retours à la ligne comme le montre l’exemple suivant :

 

WriteLn(‘Fichier: ‘, file,

‘ Date de création:‘, datecrea,

‘ Utilisateur courant:‘, nom,

‘ Numéro de code:‘, Round(ArcTan(x_enter)*y_old):0:10) ;

 

  • Les noms de constantes, variables, procédures, fonctions, tableaux, etc. (appelés identificateurs) doivent êtres des noms simples, par exemple, n’appelez pas une

 

variable comme ça: x4v_t3la78yugh456b2dfgt mais plutôt comme cela: discriminant (pour un programme sur les équations du 2nd degré) ou i (pour une variable de boucle).

  • Les identificateurs doivent impérativement être différents de ceux d’unités utilisées, de mots réservés du langage Pascal et ne doivent pas excéder 127 signes (1 lettre au minimum). Ils ne doivent être composés que de lettres, de chiffres et du caractère de soulignement (touche 8).
  • Les identificateurs ne doivent pas contenir de caractères accentués, ni d’espace, ni de point et ni les caractères suivants : @, $, &, #, +, -, *, /. Mais le caractère de soulignement (Under score) est autorisé. De plus, Turbo Pascal ne différencie aucunement les majuscules des minuscules. Les chiffres sont acceptés en première place.
  • N’hésitez pas à insérer des commentaires dans votre code, cela vous permettra de comprendre vos programmes après les avoir écrit, et ainsi d’autres personnes n’auront aucun mal à réutiliser vos procédures, fonctions… Procédez ainsi : { ici votre commentaire entre accolades } (* ici vos commentaires entre parenthèses et étoiles *).

Vos commentaires peuvent tenir sur une seule ligne comme sur plusieurs. Vous pouvez aussi mettre en commentaire une partie de votre programme.

  • Un identificateur ne peut être égal à un mot réservé du langage pascal !

I.4 Entrées et sorties à l’écran

La commande write permet d’afficher du texte et de laisser le curseur à la fin du texte affiché. Cette commande permet d’afficher des chaînes de caractères n’excédant pas 255 signes ainsi que des valeurs de variables, de constantes, de types… Le texte doit être entre apostrophe. Si le texte à afficher contient une apostrophe, il faut alors la doubler. Les différents noms de variables doivent êtres séparés par des virgules.

 

Note : toute commande doit être suivie d’un point virgule.

 

Syntaxe :

Write (‘Texte à afficher‘, variable1, variable2, ‘texte2‘) ;

Write (‘L »apostrophe se double.‘) ;

 

La commande WriteLn est semblable à la précédente à la différence près que le curseur est maintenant renvoyé à la ligne suivante.

 

Syntaxe :

WriteLn (‘Texte avec renvoi à la ligne‘) ;

 

La commande read permet à l’utilisateur de rentrer une valeur qui sera utilisée par le programme. Cette commande ne provoque pas de retour Chariot, c’est-à-dire que le curseur ne passe pas à la ligne.

 

Syntaxe :

Read (variable) ;

La commande ReadLn permet à l’utilisateur de rentrer une valeur qui sera utilisée par le programme. Cette commande provoque le retour Chariot, c’est-à-dire que le curseur passe à la ligne suivante. Lorsqu’aucune variable n’est affectée à la commande, il suffit de presser sur <ENTREE>.

 

Syntaxe :

ReadLn (variable1, variable2) ;

ReadLn ;

 

Program exemple1;

Var nom : String ;

BEGIN

Write(‘Entrez votre nom : ‘) ;

ReadLn(nom) ;

WriteLn(‘Votre nom est ‘, nom) ;

ReadLn ;

END.

 

Ce programme exemple1 déclare tout d’abord la variable nommée nom comme étant une chaîne de caractère (String). Ensuite, dans le bloc programme principal, il est demandé à l’utilisateur d’affecter une valeur à la variable nom qui est initialisée automatiquement (valeur nulle) à chaque démarrage du programme. Ensuite, il y a affichage de la valeur de la variable et attente que la touche entrée soit validée (ReadLn).

 

Exercice 1 :

Ecrire un programme en pascal affichant le texte suivant :

 

Bienvenus aux stagiaires de la 1ère année Gestion Informatisée.

 

Exercice 2 :

Ecrire un programme en pascal affichant le texte suivant :

 

Bienvenus

Aux

Stagiaires

De la

1ère

Année

Gestion

Informatisée.

 

Exercice 3 :

Ecrire un programme en pascal qui lit une variable entière X entrée au clavier et d’afficher après sa valeur.

I.5 Les types de variables.

  • Shortint : entier compris entre -127 et 128
  • Byte : entier compris entre 0 et 255
  • Integer : entier compris entre -32 768 et 32 767
  • Word : entier compris entre 0 et 65535
  • Longint : entier long compris entre – 2 147 483 648 et 2 147 483 647
  • Real : réel compris entre 2,9 e 10-39 et 1,7 e 1038 avec 11 décimales
  • Char : caractère alphanumérique
  • String : chaîne de caractères.
  • Boolean : valeurs logiques égales à TRUE ou FALSE

I.6 Affectation.

Syntaxes :

Y := 2019 ;

On donne ainsi la valeur 2019 à la variable Y (déclarée préalablement en INTEGER).

LETTRE := ‘a’ ;

On affecte la valeur a à la variable LETTRE (déclarée préalablement en CHAR).

TEST := true ;

On donne la valeur true (vrai) à la variable TEST (déclarée préalablement en BOOLEAN).

NOMBRE := Y + 103 ;

Il est ainsi possible d’utiliser les valeurs d’autres variables, du moment qu’elles sont de même type, sinon, il faut faire des conversions au préalable.

DELTA := sqr(b) – 4*(a*c) ;

I.7 Fonctions  mathématiques Pascal de base

Syntaxe Fonction

Sin(a) sinus

Cos(a) cosinus

ArcTan(a) arctangeante

Abs(a) valeur absolue

Sqr(a) carré

Sqrt(a) racine carré

Exp(a) exponentielle

Ln(a) logarithme népérien

 

I.8 Opérations

Syntaxe Type de variables Description
Inc (a); Tout type Le nombre a est incrémenté de 1
Inc (a, n) ; Tout type Le nombre a est incrémenté de n
Dec (a) ; Tout type Le nombre a est décrémenté de 1
Dec (a, n) ; Tout type Le nombre a est décrémenté de n
Trunc (a) ; Tout type Prise de la partie entière du nombre a sans arrondis
Int (a) ; a : Real

Int (a) : Lonint

 Prise de la partie entière du nombre a sans arrondis
Frac (a) ; Real Prise de la partie fractionnaire du nombre a
Round (a) A :Real

Round (a) : Longint

 Prise de la partie entière du nombre a avec arrondis à l’unité la plus proche
Odd (a) A : Longint

Odd (a) : Boolean

 Renvoit true si le nombre a est impaire et false si le nombre est paire

 

Chapitre II : Opérateurs

 

Opérateurs mathématiques

Addition +

Soustraction –

Division /

Multiplication *

Egalité =

MOD : renvoie le reste de la division x MOD y

DIV : renvoie le quotient de la division x DIV y

Opérateurs prioritaires : *, /, DIV et MOD. Opérateurs secondaires : + et -. Vous pouvez

utiliser des parentèses.

 

Opérateurs relationnels

Inférieur strict <

Inférieur ou égale (et inclu1) <=

Supérieur strict >

Supérieur ou égale (et contenant1) >=

Différent <>

 

Opérateurs logiques :

AND : le « et » logique des maths

OR : le « ou »

XOR : le « ou » exclusif

NOT : le « non »

 

Opérateur ultra-prioritaire : NOT. Opérateur semi-prioritaire : AND. Opérateur non

prioritaires : OR et XOR.

 

Priorité des opérateurs

Niveau 1 : NOT.

Niveau 2 : *, /, MOD, DIV, AND.

Niveau 3 : +, -, OR, XOR.

Niveau 4 : =, <, >, <=, >=, <>.

 

Exercice : Indiquer ce que contiennent les cases mémoires associées aux variables alpha, beta, gamma, I et n au cours de l’exécution du programme suivant :

 

Program escalope;

var alpha, beta, gamma : integer;

I,n : boolean;

begin

alpha:=1;

beta:=alpha+1;

gamma:=2*beta-3;

beta:=beta+1;

alpha:=alpha div 2;

I:=true;

n:=false;

n:=(true)or(false);

end.

Chapitre III : Les tests

 

If …then …else;

 

Remarque : dans toute la suite, on entend par instruction, une instruction simple, ou une suite

d’instructions commençant par begin et finissant par end.

 

I. Syntaxe générale de l’instruction if :

Elle peut prendre une de ces deux formes :

 

If expression_booléenne then instruction

If expression_booléenne  then instruction_1

     else instruction_2

 

Program exemple3a ;

Var chiffre:integer ;

BEGIN

Write(‘Entrez un entier pas trop grand : ‘) ;

Readln(chiffre) ;

If chiffre < 100 then writeln(chiffre, ‘ est inférieur à cent.‘) else

writeln(chiffre, ‘ est supérieur ou égale à cent.‘) ;

END.

 

Program exemple3b ;

Var chiffre:integer ;

BEGIN

Write(‘Entrez un entier pas trop grand : ‘) ;

Readln(chiffre) ;

If chiffre < 100 then

begin

writeln(chiffre, ‘ est inférieur à cent.‘) ;

end

else

begin

writeln(chiffre, ‘ est supérieur ou égale à cent.‘) ;

end ;

END.

 

 

 

Chapitre IV : Les Structures répétitives

 

  1. For … : = … To … Do …
  2. For … : = … DownTo … Do …
  3. Repeat … Until …
  4. While … Do …

 

1. For … : = … To … Do …

Cette instruction permet d’incrémenter une variable à partir d’une valeur inférieur jusqu’à une

valeur supérieur et d’exécuter une ou des instructions entre chaque incrémentation. Les valeurs inférieurs et supérieurs doivent être des entiers (integer). La boucle n’exécute les instructions de son bloc interne que si la valeur inférieur est effectivement inférieur ou égale à celle de la borne supérieur.

 

Syntaxe :

For compteur := début  to fin do instruction

 

Autre syntaxe :

For variable := début  To fin Do

Begin

Instruction_1;

Instruction_2;

…

Instruction_n;

End ;

 

Program exemplefor ;

Var i : integer ;

BEGIN

For i := 10 To 53 Do writeln (‘Valeur de i : ‘, i ) ;

Readln;

END.

 

2. For … : = … DownTo … Do …

Cette instruction permet de décrémenter une variable à partir d’une valeur supérieur jusqu’à une valeur inférieur et d’exécuter une ou des instructions entre chaque décrémentation.

 

Syntaxe :

For compteur := fin  DownTo début  Do instruction ;

 

Autre Syntaxe :

For variable := fin  DownTo début Do

Begin

Instruction_1;

Instruction_2;

…

Instruction_n;

End ;

 

 

Program downto ;

Var i : integer ;

BEGIN

For i := 100 DownTo 0 Do

Begin

WriteLn (‘Valeur de i : ‘, i ) ;

End ;

Readln;

END.

 

3. Repeat … Until …

Cette boucle effectue les instructions placées entre le repeat et le until et évalue à chaque répétition une condition booléenne avant de continuer la boucle pour décider l’arrêt ou la continuité de la répétition. Il y a donc au moins une fois exécution des instructions.

 

Syntaxe :

Repeat

Instruction_1;

Instruction_2;

…

Instruction_n;

Until expression_booléenne ;

 

Program bouclerepeat ;

Var i : integer ;

BEGIN

Repeat

Inc (i);

Writeln (‘Boucle itérée ‘, i, ‘ fois.‘);

Until i > 20 ;

END.

 

Ce programme permet de répéter l’incrémentation de la variable i jusqu’à que i soit supérieure à 20.

 

4. While … Do …

Ce type de boucle, contrairement à la précédente, évalue une condition avant d’exécuter des instructions (et nom pas l’inverse), c’est-à-dire qu’on peut ne pas entrer dans la structure de répétition si les conditions ne sont pas favorables.

 

Syntaxe :

While expression_booléenne Do instruction ;

 

Autre Syntaxe :

While expression_booléenne Do

Begin

Instruction_1;

Instruction_2;

…

Instruction_n;

End ;

 

Program bouckewhile ;

Var code : boolean ;

essai : string ;

Const levraicode = ‘commerce‘ ;

BEGIN

code:=false ; { facultatif, la valeur false est donnée par défault }

While code = false Do

Begin

Write (‘Entrez le code secret : ‘) ;

Readln (essai) ;

If essai = levraicode then code:=true ;

End ;

END.

 

Chapitre V : Les Tableaux

5.1 Définition :

Un tableau est une variable complexe (composée de d’autres variables élémentaires), il est courant d’utiliser des tableaux afin d’y stocker temporairement des données. L’intérêt du tableau est de pouvoir stocker en mémoire des données que l’on pourra retrouver grâce à d’autres valeurs à l’aide de boucles, de formules, d’algorithmes. On peut utiliser un tableau afin de représenter l’état d’un échiquier, le résultat d’une fonction mathématique… Il est possible d’introduire des variables de presque tous les types au sein d’un tableau : Char, Integer, Real,String, Byte, Record, etc.

 

Un tableau, tout comme une variable quelconque doit être déclaré dans la partie déclarative du programme. On doit toujours spécifier le type des variables qui seront introduites dans le tableau.

 

Syntaxe :

Var nom_du_tableau : Array[MinDim..MaxDim] Of type ;

 

Note : les valeurs MinDim et MaxDim doivent être des Integer ou des Char (c’est-à-dire

de type énuméré). Avec MinDim inférieur à MaxDim. L’un ou les deux peuvent êtres négatifs.

Le type des variables qui seront mises dans le tableau devra être celui là : type.

 

Remarque : il ne peut y avoir qu’un seul type de variable au sein d’un tableau.

 

Exemples :

Var tab2 : Array[1..100] Of Integer ;

Var tab3 : Array[-10..10] Of Real ;

Var tab4 : Array[50..60] Of String ;

Var tab5 : Array[‘A’..’S’] Of Char ;

 

Un tableau peut avoir plusieurs dimensions. Si toutefois, vous imposez trop de dimensions ou

des index trop importants, une erreur lors de la compilation vous dira : Error 22:

Structure too large.

 

Syntaxes :

Var nom_du_tableau : Array[MinDim1..MaxDim1, MinDim2..MaxDim2] Of

type ;

Var nom_du_tableau : Array[MinDim1..MaxDim1, MinDim2..MaxDim2,

MinDim3..MaxDim3] Of type ;

 

Exemples :

Var tab2 : Array[0..10, 0..100] Of Integer ;

Var tab3 : Array[-10..10, -10..10] Of Real ;

Var tab4 : Array[5..7, 20..22] Of String ;

Var tab5 : Array[1..10, 1..10, 1..10, 0..2] Of Char ;

 

La technique pour introduire des valeurs dans un tableau est relativement simple. Il suffit de procéder comme pour une variable normale, sauf qu’il ne faut pas oublier de spécifier la position index (ou indice) qui indique la place de la valeur dans la dimension du tableau.

Syntaxes :

nom_du_tableau[index] := valeur ;

nom_du_tableau[index1, index2] := valeur ;

 

On peut introduire dans un tableau les valeurs d’un autre tableau. Mais pour cela, il faut que les deux tableaux en question soient du même type (ou de types compatibles), qu’ils aient le même nombre de dimension(s) et le même nombre d’éléments.

 

Syntaxe :

nom_du_premier_tableau:= nom_du_deuxième_tableau ;

 

Mais une autre manière d’introduire des valeurs accompagne ce type de déclaration.

 

Syntaxe :

nom_du_tableau[index1][index2] := valeur ;

 

Exemple :

Ecrire un programme enpascal qui lit 20 notes d’examen au cavier, il les ranger dans un tableau, il calcule la moyenne de ces 20 notes, il l’affiche et ensuite il affiche le nombre d’éléves supérieurs à cette moyenne.

 

Solution:

program notes;

var tab : array[1..20] of real;

i, nbeleves : integer;

somme, moy : real;

 

begin

somme:=0;

nbeleves:=0;

 

for i:=1 to 20 do

begin

write (‘donnez la note ‘, i, ‘ SVP :’);

readln (tab[i]);

somme:=somme + tab[i];

end;

 

moy:= somme/20;

 

for i:=1 to 20 do

if tab[i]>moy then nbeleves :=nbeleves+1;

 

writeln (‘moyenne des ces 20 notes est:’, moy:0:2);

write (nbeleves, ‘eleves ont plus de cette moyenne’);

readln;

end.

 

 

 

 

Chapitre VI : Chaîne de Caractères

1. Chaînes de caractères (type string) :

Le type String défini des variables « chaînes de caractères » ayant au maximum 255 signes, une chaîne peut en contenir moins si cela est spécifié lors de la déclaration où le nombre de signes (compris entre 1 et 255) sera mis en crochet à la suite du type String. Le premier caractère de la chaîne a pour indice 1, le dernier a pour indice 255 (ou moins si spécifié lors de la déclaration).

 

Syntaxe:

Var chaine : String ;

telephone : String[10] ;

 

Lorsqu’une valeur est affectée à une variable chaîne de caractères, on procède comme pour un nombre mais cette valeur doit être entre quottes. Si cette valeur contient une apostrophe, celle-ci doit être doublée dans votre code.

 

Syntaxe :

variable := valeur ;

animal := ‘l »abeille’ ;

 

Note très importante : le type String est en fait un tableau de caractères à une dimension dont l’élément d’indice zéro contient la longueur de la chaîne. Il est donc possible, une chaîne de caractère étant un tableau de modifier un seul caractère de la chaîne grâce à la syntaxe suivante :

 

chaine[index]:=lettre;

 

Program Chaine;

Var nom:String;

 

BEGIN

nom:=’Etievant’;

nom[2]:=’Z’;

nom[0]:=Chr(4);

WriteLn(nom);

nom[0]:=Chr(28);

Write(nom,’-tagada’);

 

END.

 

L’exemple Chaine remplace la deuxième lettre de la variable nom en un « Z » majuscule, puis spécifie que la variable ne contient plus que 4 caractères. Ainsi la valeur de la variable nom est devenue : EZie. Mais après, on dit que la variable nom a une longueur de 28 caractères et on s’aperçoit à l’écran que les caractères de rang supérieur à 4 ont été conservés et des espaces ont été insérés pour aller jusqu’à 28 ! Ce qui veut dire que la chaîne affichée n’est pas toujours la valeur totale de la chaîne réelle en mémoire.

2. Fonctions appliquées aux chaînes de caractères :

A/ Concat ( s1, s2, s3, …, sn) ;

Cette fonction concatène les chaînes de caractères spécifiés s1, s2, etc. en une seule et même chaîne. On peut se passer de cette fonction grâce à l’opérateur + : s1 + s2 + s3 + … + sn. Rappelons que les chaînes de caractères sont généralement définies en string.

 

Syntaxes:

s := Concat ( s1, s2 ) ;

s := s1 + s2 ;

 

B/ Copy ( s, i, j ) ;

Fonction qui retourne de la chaîne de caractère s, un nombre j de caractères à partir de la position i (dans le sens de la lecture). Rappelons que i et j sont des entiers (integer).

 

C/ Delete ( s, i, j ) ;

Procédure qui supprime dans la chaîne nommée s, un nombre j de caractères à partir de la position i.

 

D/ Insert ( s1, s2, i ) ;

Procédure qui insert la chaîne s1 dans la chaîne s2 à la position i.

 

Exemple 1: qu’affiche le programme suivant après son exécution ?

program chaine;

var m1, m2, m3 : string;

begin

m1 :=’voici ‘;

m2:= ‘une’;

m3:= Concat (m1,m2);

write (m3);

readln;

end.

 

Remarque : on pouvait écrire m3 :=m1 +m2 à la place de m3:= Concat (m1,m2); ceci donnera le même résultat.

 

Exemple2 : Ecrire un programme qui copie d’une chaîne de caractère m1 initialisée à :’2LMD sciences commerciales’, la valeur :’sciences commerciales’ qui sera mise dans la chaîne m2 qu’il affiche parés à l’écran.

 

Solution2 :

program chaine;

var m1, m2: string;

begin

m1 :=’2LMD sciences commerciales ‘;

m2:= copy(m1,6,21);

write (m2);

readln;

end.

 

Utilisation des fonctions mathématiques

 

Exercice :

Soit une équation du 2e degré sous la forme de ax2 +bx +c = 0, où a, b, c sont des réels, écrire un programme en pascal qui permet de résoudre cette équation, je rappelle qu’il faut d’abord calculer le discriminant Delta = b2 – 4 * a * c.

 

si Delta>0 l’équation a 2 racines réelles distinctes que l’on

calcule avec (-b+Delta)/(2*a)

et (-b-Delta)/(2*a)

 

si Delta=0, les 2 formules ci-dessus sont encore valables

et fournissent 2 valeurs égales -b/(2*a)

si Delta<0, les 2 formules contenant Delta ne sont

plus valables dans les réels.

 

Utilisez les fonctions sqr et sqrt pour ce résoudre ce problème.

 

Solution :

 

program eqaution2degre;

var a, b, c, delta, x1, x2, x : real;

begin

write (‘intoduisez le coefficient a SVP:’);

readln (a);

write (‘intoduisez le coefficient b SVP:’);

readln (b);

write (‘intoduisez le coefficient c SVP:’);

readln (c);

 

writeln (‘Resolution de l »equation :’, a:0:2,’x2 + ‘,b:0:2,’x + ‘,c:0:2,’ =0′);

 

delta:=sqr(b)-4*a*c;

 

writeln(‘delta est :’, delta:0:2);

 

if delta>0 then

begin

writeln (‘l »equation a deux racines reelles x1 et x2’);

x1:=(-b+sqrt(delta))/(2*a);

x2:=(-b-sqrt(delta))/(2*a);

writeln (‘x1 est :’, x1:0:2);

writeln (‘x2 est :’, x2:0:2);

end

 

else if delta=0 then

begin

write (‘l »equation a deux racines reelles égales x:’);

x:=-b/(2*a);

write(‘x est :’, x:0:2);

end

else write (‘l »equation n a pas de solution dans R’);

 

readln;

end.

Chapitre VII : Booléens et tables de vérité

 

Les booléens ont été inventés par Monsieur Boole dans le but de créer des fonctions de base qui, associées les unes aux autres, pourraient donner d’autres fonctions beaucoup plus complexes.

 

Les booléens (boolean en anglais et en Pascal) ne peuvent prendre que deux valeurs possibles : vrai (true) ou faux (false) et sont codés en 0 ou 1. Ces valeurs sont analogues aux états possibles d’un interrupteur : ouvert ou fermé, d’une lampe : allumée ou éteinte.

 

En bref, les booléens ne sont utiles que pour connaître un état : vrai ou faux et en général pour caractériser si une condition est vraie ou fausse. Vous les utilisez déjà sans toujours le savoir dans les blocs IF : si telle condition est vraie, alors…

 

Boole inventa une algèbre qui porte son nom : l’algèbre de Boole. C’est cette dernière qui nous permet de faire des opérations sur les booléens grâce à des opérateurs : NOT (non), OR (ou), AND (et), XOR (ou exclusif), NAND (inverse de et), NOR (inverse de ou). Ainsi, NAND=NOT(AND) et NOR=NOT(OR).

 

7.1 Tables de vérité des opérateurs logiques :

 

NOT

X NOT X
false true
true false

 

AND

X Y X AND Y
false false False
false true False
true false False
true true True

 

OR

X Y X OR Y
false False False
false True True
true False True
true True True

 

XOR

X Y X XOR Y
false False False
False True True
true True True
true true False

 

 

Comme toute variable, il faut déclarer une variable booléenne dans la partie déclarative en entête du programme.

 

Syntaxe :

Var nomdevariable : boolean ;

 

Pour donner une valeur à une variable booléenne, on procède comme pour tout autre type de variable, à l’aide du commutateur := .

 

Syntaxes :

nomdevariable := true ;

nomdevariable := false ;

 

Note : par défaut, une variable booléenne est FALSE (tout comme une variable INTEGER est égale à zéro lors du lancement du programme).

 

On peut bien évidemment utiliser une structure IF.

 

Syntaxe :

If condition then nomdevariablebooléenne := true ;

 

Il existe une autre façon de donner la valeur true (ou false) à une telle variable, bien plus simple qu’une structure IF.

 

Syntaxe :

nomdevariable := condition ;

 

Exemple :

test := (x>100) and (u=’coucou‘) ;

 

Dans une structure conditionnelle (If, Until, While), on peut avantageusement utiliser des booléens sans spécifier sa valeur qui sera alors prise par défaut égale à true.

 

Syntaxes :

If nomdevariablebooléenne then instruction ;

 

Repeat

instructions

Until nomdevariable ;

While nomdevariable do instruction end ;

 

Nous avons vu plus haut que les opérateurs spécifiques aux booléens (NOT, OR, AND, XOR) pouvaient se composer pour donner des expressions plus complexes. Il est bien entendu possible d’introduire dans ces expressions le opérateurs relationnels (=, <, >, <=, >=, <>) et plus généralement tous les autres opérateurs disponibles en Turbo Pascal. Pour pouvez même utiliser directement des expressions qu’elles soient mathématiques ou non.

Exemples :

test := (lenght(u)<= 20) or ((sin(a)*pi) < x) ;

Ici, la variable booléenne test devient vraie si la longueur de la chaîne u n’excède pas 20 caractères ou si le sinus de l’angle a multiplié par la valeur de pi est strictement inférieur à la valeur de x.

If (a=0) or ((b=0) and (c=0)) then writeln(‘La lampe est allumée‘);

Ici, écriture à l’écran d’un message si a est nul ou si b et c sont simultanément nuls.

Note : si vous faites afficher à l’écran la valeur d’une variable booléenne, il s’affichera FALSE ou TRUE (selon sa valeur effective) en caractères majuscules.

   

un autre cours à télécharger