Les instructions

Dans le cours qui va suivre, nous allons utiliser un pseudolangage, comportant toutes les structures de base d'un langage de programmation.

Article lu   fois.

L'auteur

Site personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Introduction

Les instructions sont les opérations qui vont permettre de faire interagir les différents objets entre eux.
Nous distinguerons trois types d'instructions nous permettant d'accéder à cinq instructions ce qui est largement suffisant pour traiter l'ensemble des problèmes rencontrés.

II. Instruction d'affectation

L'instruction d'affectation nous permet de donner une valeur à une variable, dans la mesure où cette variable est d'un type simple.
Il n'est pas possible d'affecter directement des variables de type complexe, mais nous pouvons affecter leur champs ou éléments s'ils sont de type simple (entier, booléen, caractère, réel, pointeur).

Exemple d'affectation
Sélectionnez
variables i : entier 
i := 3 
i := i + 1 
i := 4 * i

III. Instructions alternatives

III-A. L'instruction SI

Elle permet d'effectuer une ou plusieurs instructions si une certaine condition est remplie :
(Si il fait beau, je vais à la plage).

Elle permet également d'effectuer un traitement si cette condition est remplie et un autre traitement dans le cas contraire.
(Si il fait beau je vais à la plage , sinon je vais au ciné).

SI condition ALORS actions [SINON actions] FSI

Exemple d'instruction SI
Sélectionnez
Si i>4 ALORS 
  i := i-1 
SINON 
  i := 1 + 1 
FSI

III-B. L'instruction CHOIX

Elle permet d'associer à différentes valeurs discrètes des instructions à exécuter.
Cette instruction peut être réalisée par une cascade de SI SINON, mais elle offre une présentation et une lecture plus agréable et compréhensive.

 
Sélectionnez
CHOIX SUR FAIRE 
   <valeur 1>  <instruction 1 1> 
               <instruction 1 2> 
               <instruction 1 n(1)> 
                   
   <valeur m>  <instruction m 1> 
               <instruction m 2> 
               <instruction m n(m)> 
                 
   AUTRECAS    <instruction (m + 1) 1> 
               <instruction (m+1) n(m+1)> 
FINCHOIX

Il est obligatoire de mettre AUTRECAS, même dans les cas ou il n'y en a pas, car cela donne l'occasion au concepteur de l'algorithme de faire le point sur tous les cas énumérés.

Exemple
Sélectionnez
Variables i : entier 
CHOIX SUR i FAIRE 
  1 : ECRIRE ('numero1') 
  2 : ECRIRE ('numero2') 
  3 : ECRIRE ('numero3') 
AUTRE CAS : ECRIRE ('choix impossible') 
FINCHOIX

IV. Instructions répétitives

Il existe deux formes d'instructions itératives, ces deux formes sont légèrement différentes et correspondent à deux types de problèmes différents.
Il est important de bien voir la différence entre ces deux formes.

Trois choses caractérisent les instructions itératives :

  • une éventuelle répétition des actions ;
  • une évolution de notre univers par ces actions ;
  • une condition de terminaison testée sur notre univers.

IV-A. L'instruction TANTQUE

Elle permet d'exécuter une instruction tant qu'une condition est remplie .
Il est préférable que la condition puisse être changée par les instructions, sinon notre algorithme ne terminerait jamais exemple (tant qu'il fait beau, je reste à la plage).

TANTQUE condition FAIRE actions FTQ

Exemple
Sélectionnez
Variable i : entier 
TANTQUE (i < 3 ) FAIRE // on arrete quand i >=3 
  i : = i + 1 
  écrire ('hello') 
FTQ 
écrire('i= ',i)

Prenez le cas où i=5 avant l'exécution de notre TANTQUE, la condition n'étant pas remplie on n'effectue pas la boucle, on va donc directement effectuer l'instruction écrire('i=",i), le résultat est alors I=5.

Prenez le cas où i =1 avant l'exéxution de notre TANTQUE, la condition est remplie, on incrémente i, on écrit hello, et on vient à nouveau tester la condition.
La condition est de nouveau remplie, on incrémente i et on écrit hello. i vaut maintenant 3, et on revient tester notre condition qui n'et plus remplie.

On va donc écrire le résultat:
coucou
coucou
i = 3

IV-B. L'instruction REPETER

Elle permet d'exécuter une instruction jusqu'à ce qu'une condition soit remplie.
Ceci correspond à une formulation du type : je bois jusqu'à ne plus avoir soif (ce qui implique que l'on boit avant de se poser la question si l'on a soif).

REPETER/FAIRE actions JUSQUA condition

Exemple
Sélectionnez
Variable i : entier 
REPETER 
  i : = i + 1 
  écrire ('hello') 
JUSQUA (i >3 ) // la boucle se termine quand i>=3 
écrire('i= ',i)

Prenez le cas où i =5 avant l'exécution du REPETER, on commence par incrémenter i, puis on écrit hello.
La condition de terminaison est vérifiée, on écrit donc le résultat.
Les écritures correspondant à cette exécution sont :

coucou
i = 6

Prenez le cas où i =1 avant l'exécution du répéter, on commence par incrémenter i, puis par écrire hello.
On teste la condition de terminaison qui n'est pas vérifiée.
On incrémente à nouveau i, on écrit hello, on teste la condition de sortie qui est vérifiée.
les écritures correspondant à cette exécution sont :

coucou
coucou
i = 3

V. Liste de mes articles

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2013 Selkis. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.