Programmation/Contrôles
Généralement, le code source d'un programme décrit l'exécution en une suite d'instructions. Par défaut, ces instructions sont exécutées dans l'ordre séquentiel, suivant l'ordre d'écriture du code source (de gauche à droite, de haut en bas).
Exemple :
A ← 3 B ← A + 1
L'ordre d'exécution est alors le suivant :
A ← 3On affecte la valeur 3 à la variable A.B ← A + 1On affecte la valeur 4 (A+1 = 3+1) à la variable B.
Il peut être nécessaire de changer cet ordre pour diverses raisons :
- N'exécuter certaines instructions que si une condition est remplie (instructions conditionnelles),
- Répéter en boucle le même traitement plusieurs fois (boucle).
Le changement d'ordre d'exécution est effectué par les instructions de contrôle d'exécution.
Regroupement d'instructions
[modifier | modifier le wikicode]Les sections qui suivent parle d'une instruction, mais il est possible d'utiliser plusieurs instructions en les regroupant dans un bloc. Ce bloc est alors utilisable là où le terme « une instruction » est employé.
Un bloc est délimité par des caractères spéciaux ou des mots réservés du langage.
Beaucoup de langages de programmation utilisent les accolades pour délimiter un bloc (C, C++, Java, C#, Javascript, PHP, ...) :
{
instruction1
instruction2
...
}
D'autres utilisent des mots réservés :
En Pascal, Delphi et Ada :
BEGIN
instruction1
instruction2
...
END;
En Visual Basic, les mots utilisés dépendent de l'instruction :
If ...
instruction1
instruction2
...
EndIf
For ...
instruction1
instruction2
...
Next
Instruction conditionnelle
[modifier | modifier le wikicode]Une instruction conditionnelle n'est exécutée que si une condition est vraie. Elle peut être conditionnée par l'existence d'un fichier, la valeur d'une variable ou expression, l'absence d'erreur retournée par une fonction, ...
Beaucoup de langage de programmation possède une instruction if (mot anglais signifiant si) pour tester une condition. La syntaxe générale est la suivante :
SI condition ALORS
instruction_si_condition_vraie
FINSI
Une autre syntaxe autorise également l'exécution d'une instruction quand la condition est fausse.
SI condition ALORS
instruction_si_condition_vraie
SINON
instruction_si_condition_fausse
FINSI
Chacun des mots est à remplacer par celui utilisé par le langage, utilisant souvent leur équivalent anglais (SI → IF, ALORS → THEN, SINON → ELSE, FINSI → ENDIF). Le mot ALORS peut être absent dans certains langages, car implicite.
En C, C++, Java, C#, Javascript, PHP :
if (condition)
instruction_si_condition_vraie
else
instruction_si_condition_fausse
|
Exemple en Java :
if (a < b)
System.out.println("A est plus petit que B");
else
System.out.println("A égale ou est plus grand que B");
|
En Pascal, Delphi :
IF condition THEN
instruction_si_condition_vraie
ELSE
instruction_si_condition_fausse
En Visual Basic :
If condition Then
instruction_si_condition_vraie
Else
instruction_si_condition_fausse
EndIf
Boucle
[modifier | modifier le wikicode]Une boucle permet de répéter une instruction un nombre de fois déterminé ou non. La boucle générale exécute l'instruction à répéter tant qu'une condition est vraie. La condition peut être évaluée avant l'instruction ou après. Certains langages autorisent aussi une forme de boucle qui se termine quand une condition devient vraie.
Une itération est une exécution particulière de l'instruction dans une boucle. Voir les sections ci-dessous qui détaillent les types de boucle.
Boucle conditionnelle
[modifier | modifier le wikicode]La boucle conditionnelle exécute une instruction (ou bloc d'instructions) tant qu'une condition est vraie ou fausse.
Condition testée avant
[modifier | modifier le wikicode]La boucle « tant que » exécute instruction tant qu'une condition est vraie, c'est-à-dire jusqu'à ce que la condition soit fausse. Tant que la condition est vraie, une nouvelle itération a lieu.
Elle a en général la forme suivante :
TANT_QUE condition FAIRE instruction
La condition est testée avant, ce qui signifie que l'instruction peut ne pas être exécutée si la condition est fausse initialement.
Exemple en Java :
while (a < b)
a = a + 10;
Avec un bloc d'instruction :
while (a < b)
{
a = a + 10;
System.out.println("Nouvelle valeur de A = "+a);
}
Condition testée après
[modifier | modifier le wikicode]La boucle peut avoir également cette forme :
FAIRE instruction TANT_QUE condition
La condition est testée après, ce qui signifie que l'instruction est exécutée au moins une fois même si la condition est fausse initialement.
do
{
a = a + 10;
}
while (a < b);
Répéter jusqu'à
[modifier | modifier le wikicode]Une autre forme de la boucle répète une instruction jusqu'à ce que la condition soit vraie, c'est-à-dire tant que la condition est fausse. Tant que la condition est fausse, une nouvelle itération a lieu.
La forme la plus courante est celle où la condition est testée après l'instruction :
RÉPÉTER instruction JUSQU_À condition
Il existe aussi une forme où la condition est testée avant l'exécution de l'instruction :
JUSQU_À condition RÉPÉTER instruction
Boucle d'itération d'un ensemble
[modifier | modifier le wikicode]Ce type de boucle effectue une itération pour chacun des éléments d'un ensemble. Une variable associée prend les différentes valeurs successives des éléments de l'ensemble.
Entiers
[modifier | modifier le wikicode]On trouve cette forme dans les premiers langages de programmation (Fortran, Basic, Pascal). Les langages de programmation plus récents utilisent en général une autre forme de la boucle.
Cet ensemble peut être celui des entiers en spécifiant les bornes minimales et maximales :
POUR variable DE min À max FAIRE instruction_qui_peut_utiliser_variable
Le pas par défaut est de un, certains langages permettent de spécifier un autre pas :
POUR variable DE min À max PAS_DE pas FAIRE instruction_qui_peut_utiliser_variable
Un pas de -1 permettant de parcourir en sens inverse.
D'autres langages supporte un sens automatique de parcours inversé quand la borne min est plus grande que max.
Itération par condition explicite
[modifier | modifier le wikicode]La plupart des langages supporte cette forme de boucle générale. Elle est composée de trois parties contrôlant l'exécution en plus de l'instruction à exécuter :
- l'initialisation d'une ou plusieurs variables,
- l'expression définissant la condition d'itération (testée avant exécution),
- l'instruction d'incrémentation permettant de passer à l'élément suivant.
POUR initialisation TANT_QUE condition SUIVANT incrémentation FAIRE instruction
Exemple en Java :
for (int nombre = 1 ; nombre<=10 ; nombre++)
System.out.println("Le carré de "+nombre+" est "+(nombre * nombre));
Ensemble générique
[modifier | modifier le wikicode]D'autres langages (Python, C Sharp, Java) permettent de spécifier un ensemble générique (éléments d'un tableaux, d'une liste...).
POUR variable DANS ensemble_à_parcourir FAIRE instruction_qui_peut_utiliser_variable
Exemple pour afficher tous les éléments d'un tableau en Java :
String[] mots = { "Une","phrase","comportant","plusieurs","mots" };
for (String mot : mots)
System.out.println(mot);