Tests et boucles

1. Les tests

1.1 Structure

Aucune originalité sur ce point. Une structure de test en C# possède la syntaxe suivante :

if (booléen)
{
   instructions
}

Le C# ignore donc l'instruction de fin de bloc (« Endif »). L'infomation est donnée par la fermeture des accolades.

Il est possible de compléter la série d'instructions par un else :

if (booléen)
{
   instructions
}
else
{
   instructions
}

Remarque : on notera avec intérêt (et incrédulité) que le C# ignore l'instruction « elseif ». En cas de besoin, il faudra donc se passer de cette forme contractée et en rester à la forme développée, à savoir une nouvelle structure if ... imbriquée dans le else.

1.2 Opérateurs logiques

Le récapitulatif des opérateurs logiques se trouve dans le chapitre consacré à l'ensembl des opérateurs, et plus précisément à cet endroit.

2. Les boucles

1.1 La boucle While

Il s'agit bien entendu de l'équivalent du TantQue... algorithmique. Que dire de plus ?

while (booléen)
{
   instructions
}

1.2 La boucle For

Deuxième incontournable, la boucle à compteur (Pour...). Attention, elle se formule d'une manière qui, au départ, peut quelque peu dérouter :

for (initialisation; condition; itération)
{
   instructions
}

Lors de l'initialisation, on peut se contenter d'affecter au compteur sa valeur de départ si celui-ci a été préalablement déclaré. Dans le cas contraire, il faudra procéder à cette déclaration.

Dans le cas le plus simple, celui d'un pas de 1 et d'un compteur déjà déclaré, on aura ainsi par exemple :

for (i=1; i<=10; i++)
{
   instructions
}

Dans un cas plus compliqué, avec déclaration du compteur et un pas de 3 :

for (int i=1; i<=30; i+=3)
{
   instructions
}

2.3 La boucle For ... Each

Lorsqu'on connaît uniquement la programmation procédurale, cette boucle est une vraie nouveauté, caractéristique des langages objets. Très pratique dans bien des circonstances, elle demande néanmoins un peu (beaucoup) d'attention pour être apprivoisée.

Cette boucle est particulièrement conçue pour parcourir les éléments d'un tableau ou d'une collection. On ne spécifie pas de compteur (en fait, on laisse le langage gérer lui-même l'indice en sous-main), et on se contente de lui dire : « prends-moi tous les éléments de cet ensemble, les uns après les autres, du premier au dernier ».

En voici la syntaxe :

foreach (type nom_de_variable in nom_de_l'ensemble)
{
instructions
}

La boucle foreach présente trois différences majeures avec une boucle for ordinaire :

1. la variable que l'on utilise pour effectuer le balayage ne prend pas successivement les différentes valeurs d'un indice, mais directement, les différentes valeurs du tableau ou de la collection eux-mêmes
2. au passage, la boucle foreach impose de déclarer cette variable dans l'instruction de la boucle : pas question donc de réutiliser une variable déjà déclarée auparavant.
3. enfin, last but not least (liste ?), les éléments traités dans une boucle foreach sont en lecture seule. On ne peut donc ni les modifier, ni les ajouter, ni les supprimer.

Ainsi, pour mettre à zéro tous les éléments d'un tableau d'entiers appelé mesReleves, il ne sera pas question d'écrire :

foreach (int k in mesReleves)
{
k = 0
}

Un tel code provoquera une erreur (une « exception ») lors de l'exécution, puisqu'on aura cherché à modifier les éléments du tableau au travers de la variable k.

Tout cela diminue sérieusement les possibilités de la boucle foreach. Celle-ci reste néanmoins une écriture à connaître.