Types d'intructions
Toutes les instructions d'un programme sont écrites dans le corps du prgramme. (entre Début et Fin, i.e. Begin et End.). On peut regrouper ces instructions en trois types : les entrées/sorties (saisi de valeurs et l'affichage des résultat), l'affectation et les structures de contrôles (tests et les boucles)
Instructions d'Entrées/Sorties (Lecture / Écriture)
Entrées ( Lecture )
Une instruction d'entrée nous permet dans un programme de donner une valeur quelconque à une variable. Ceci se réalise à travers l'opération de lecture.
La syntaxe et la sémantique d'une lecture est comme suit :
Remarque :
Il est important de noter que l'instruction de lecture concerne uniquement les variables, on peut pas lire des constantes ou des valeurs. Lors de la lecture d'une variable dans un programme Pascal, le programme se bloque en attendant la saisie d'une valeur via le clavier. Une fois la valeur saisie, on valide par la touche entrée, et le programme reprend l'exécution avec l'instruction suivante.
Exemple :
Sorties ( Écriture )
Une instruction de sortie nous permet dans un programme d'afficher un résultat (données traitées) ou bien un message (chaîne de caractères). Ceci se réalise à travers l'opération d'écriture.
La syntaxe et la sémantique d'une écriture est comme suit :
Remarque :
Il est à noter que l'instruction d'écriture ne concerne pas uniquement les variables, on peut écrire des constantes, valeurs ou des expressions (arithmétiques ou logiques). On peut afficher unevaleur et sauter la ligne juste après à travers l'instruction : writeln.
Exemple :
Instruction d'affectation
Une affectation consiste à donner une valeur (immédiate, constante, variable ou calculée à travers une expression) à une variable.
La syntaxe d'une affectation est comme suit :
Une affectation possède deux parties : la partie gauche qui représente toujours une variable, et la partie droite qui peut être : une valeur, variable ou une expression. La condition qu'une affectation soit correcte est que : la partie droite doit être du même type (ou de type compatible) avec la partie gauche.
Exemple :
Structures de contrôles
En générale, les instructions d'un programme sont exécutés d'une manière séquentielle : la première instruction, ensuite la deuxième, après la troisième et ainsi de suite. Cependant, dans plusieurs cas, on est amené soit à choisir entre deux ou plusieurs chemins d'exécution (un choix entre deux ou plusieurs options), ou bien à répéter l'exécution d'un ensemble d'instructions, pour cela nous avons besoins de structures de contrôle pour contrôler et choisir les chemins d'exécutions ou refaire un traitement plusieurs fois. Les structures de contrôle sont de deux types : Structures de contrôles conditionnelles et structures de contrôle répétitives (itératives).
Structures de contrôle conditionnelle
Ces structures sont utilisées pour décider de l'exécution d'un bloc d'instruction : est ce que ce bloc est exécuté ou non. Ou bien pour choisir entre l'exécution de deux blocs différents. Nous avons deux types de structures conditionnelles :
Test alternatif simple
Un test simple contient un seul bloc d'instructions. Selon une condition (expression logique), on décide est ce que le bloc d'instructions est exécuté ou non. Si la condition est vraie, on exécute le bloc, sinon on l'exécute pas.
La syntaxe d'un test alternatif simple est comme suit :
Exemple :
Remarque :
Dans le langage Pascal, un bloc est délimité par les deux mots clés begin et end.
Si le bloc contient une seule instruction, begin et end sont facultatifs (on peut les enlever).
Test alternatif double
Un test double contient deux blocs d'instructions : on est amené à décider entre le premier bloc ou le seconds. Cette décision est réalisée selon une condition (expression logique ou booléenne) qui peut être vraie ou fausse. Si la condition est vraie on exécute le premier bloc, sinon on exécute le second.
La syntaxe d'un test alternatif double est comme suit :
Exemple :
Remarque :
- Dans le langage Pascal, il faut jamais mettre de point-virgule avant else.
- Dans l'exemple précédent, on peut enlever begin end du if et ceux du else puisqu'il y a une seule instruction dans les deux blocs.
Structures de contrôle répétitives
Les structures répétitives nous permettent de répéter un traitement un nombre fini de fois. Par exemple, on veut afficher tous les nombre premier entre 1 et N (N nombre entier positif donné). Nous avons trois types de structures itératives (boucles) :
Boucle Pour (For)
La structure de contrôle répétitive pour (for en langage Pascal) utilise un indice entier qui varie (avec un incrément = 1) d'une valeur initiale jusqu'à une valeur finale. À la fin de chaque itération, l'indice est incrémenté de 1 d'une manière automatique (implicite).
La syntaxe de la boucle pour est comme suit :
<indice> : variable entière
<vi> : valeur initiale
<vf> : valeur finale
La boucle pour contient un bloc d'instructions (les instructions à répéter). Si le bloc contient une seule instruction, le begin et end sont facultatifs.
Le bloc sera répété un nombre de fois = (<vf> <vi> + 1) si la valeur finale est supérieure ou égale à la valeur initiale. Le bloc sera exécuté pour <indice> = <vi>, pour <indice> = <vi>+1, pour <indice> = <vi>+2, ..., pour <indice> = <vf>.
Attention :
Il ne faut jamais mettre de point-virgule après le mot clé do.
Boucle Tant-que (While)
La structure de contrôle répétitive tantque (while en langage Pascal) utilise une expression logique ou booléenne comme condition d'accès à la boucle : si la condition est vérifiée (elle donne un résultat vrai : TRUE) donc on entre à la boucle, sinon on la quitte.
La syntaxe de la boucle tantque est comme suit :
<condition> : expression logique qui peut être vraie ou fausse.
On exécute le bloc d'instructions tant que la condition est vraie. Une fois la condition est fausse, on arrête la boucle, et on continue l'exécution de l'instruction qui vient après fin Tant que (après end).
Comme la boucle for, il faut jamais mettre de point-virgule après do.
Remarque :
Il est possible de remplacer toute boucle "pour" par une boucle "tantque", cependant, l'inverse n'est pas toujours réalisable.
Boucle Répéter (Repeat)
La structure de contrôle répétitive répéter (repeat en langage Pascal) utilise une expression logique ou booléenne comme condition de sortie de la boucle : si la condition est vérifiée (elle donne un résultat vrai : TRUE) on sort de la boucle, sinon on y accède (on répète l'exécution du bloc).
La syntaxe de la boucle répéter est comme suit :
<condition> : expression logique qui peut être vraie ou fausse.
On exécute le bloc d'instructions jusqu'à avoir la condition correcte. Une fois la condition est vérifiée, on arrête la boucle, et on continue l'exécution de l'instruction qui vient après jusqu'à (après until). Dans la boucle repeat on utilise pas begin et end pour délimiter le bloc d'instructions (le bloc est déjà délimité par repeat et until).
La différence entre la boucle répéter et la boucle tantque est :
- La condition de répéter et toujours l'inverse de la condition tantque : pour répéter c'est la condition de sortie de la boucle, et pour tantque c'est la condition d'entrer.
- Le teste de la condition est à la fin de la boucle (la fin de l'itération) pour répéter. Par contre, il est au début de l'itération pour la boucle tantque. C'est-à-dire, dans tantque on teste la condition avant d'entrer à l'itération, et dans répéter on fait l'itération après on teste la condition.
Structure de contrôle de branchements / sauts (l'instruction Goto)
Une instruction de branchement nous permet de sauter à un endroit du programme et continuer l'exécution à partir de cet endroit. Pour réaliser un branchement, il faut tout d'abord indiquer la cibledu branchement via une étiquette <num_etiq> : . Après on saute à cette endroit par l'instruction aller à <num_etiq> (en pascal : goto <num_etiq>).
La syntaxe d'un branchement est comme suit :
Remarque :
- Une étiquette représente un numéro (nombre entier), exemple : 1, 2, 3, etc.
- Dans un programme Pascal, il faut déclarer les étiquettes dans la partie déclaration avec le mot clé label. (on a vu const pour les constantes var pour les variables)
- Une étiquette désigne un seule endroit dans le programme, on peut jamais indiquer deux endroits avec une même étiquette.
- Par contre, on peut réaliser plusieurs branchement vers une même étiquette.
- Un saut ou un branchement peut être vers une instruction antérieure ou postérieure (avant ou après le saut).
Exemple :
Dans l'exemple ci-dessus, il y a deux étiquettes : 1 et 2. L'étiquette 1 fait référence la dernière instruction de l'algorithme / programme (écrire(c) / write(c) ;), et l'étiquette 2 fait référence la troisième instruction de l'algorithme / programme (c ← a; / c := a;). Pour le déroulement de l'algorithme, on utilise le tableau suivant (a = 2 et b = 5) :
Il y a deux types de branchement :
Branchement inconditionnel : c'est un branchement sans condition, il n'appartient pas à un bloc de si ou un bloc sinon. Dans l'exemple précédent, l'instruction aller à 2 (goto 2) est un saut inconditionnel.
Branchement conditionnel : Par contre, un branchement conditionnel est un saut qui appartient à un bloc si ou un bloc sinon. L'instruction aller à 1 (goto 1), dans l'exemple précédent est un saut conditionnel puisque il appartient un bloc si.
