Programmation/Contrôles

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche


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 :

  1. A ← 3 On affecte la valeur 3 à la variable A.
  2. B ← A + 1 On 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);