Langage C Sharp/Fiche/Boucles et structures conditionnelles

Fiche mémoire sur les Boucles et structures conditionnelles

declaration

|entier: int (nom); |réel: float (nom); |caractère: char (nom); |chaine de caractères: typedef char CH5(nombre de caractères)[nombre de caractères +1](avant le void main) puis ch(nombre de caractères) (nom)

lecture

|entier: scanf (%f, (nom)); |réel: scanf(%d,(nom)); |caractère: (nom)=getchar(); |chaine de caractères:gets (nom);

Structures conditionnelles

Structures IF

Introduction IF

En C# comme dans beaucoup d'autres langages il peut être parfois utile voire nécessaire de savoir SI une condition est remplie avant d'exécuter une instruction (Exemple : Si un fichier n’est pas trouvé, afficher une erreur). Ce test est de type booléen : soit la condition est vraie (true), soit elle est fausse (false).

Les conditions impliquant des valeurs comparables (des nombres en général) utilisent des expressions employant des opérateurs de comparaison : est-ce que quelque-chose est plus petit que, égal à, plus grand que, différent de, etc. quelque-chose d’autre ?

En C# on utilise la fonction if en français "si".

L'instruction if est presque toujours associée à l'instruction else en français "sinon", qui permet d'exécuter une instruction si le résultat du test est faux. Malgré tout, l'instruction else n’est pas obligatoire, en particulier s'il n'y a rien à faire dans le cas où la condition est fausse.

Prenons un exemple de la vie de tous les jours :
Si tu mets la table, tu pourras manger, sinon tu ne mangeras pas.
Cet exemple illustre à merveille la structure de la fonction IF et de ELSE.

Structure IF (Simple)

Petit rappel des opérateurs de comparaison.

égal	==
pas égal/différent	!=
plus petit	<
plus petit ou égal	<=
plus grand	>
plus grand ou égal	>=

Modèle de structure :

if (test à effectuer) { Ce qui sera exécuté si le résultat du test est juste ) else { Ce qui sera exécuté si le résultat du test est faux )

Exemple:

if (x < 4)
{
   Console.WriteLine("X est plus petit que 4");
}
else
{
   Console.WriteLine("X est plus grand ou égal à 4");
}

Voici un simple bout de code qui permet d'afficher si la valeur de la variable x est inférieur à 4.

Structure IF (Complexe)

Dans certains cas il faut, par exemple que 2 variables soient égales à 4. Pour tester si ces 2 variables sont égales nous allons utiliser la fonction vu ci-dessus,.... la fonction if dont nous allons un peu modifier la condition. Petit rappel des opérateurs logiques.

ET/AND	&&
OU/OR	||
PAS/NOT	!

Modèle de structure à 2 conditions:

if((test à effectuer1)&&(test à effectuer2)) { Ce qui sera exécuté si le résultat des tests sont juste ) else { Ce qui sera exécuté si le résultat des tests sont faux )

Il suffit de créer 2 tests à effectuer et les "relier" par un opérateur logique. Puis de placer des parenthèse afin de, comme en math, créer un "groupe"
Exemple: (2 * 3) + 2 = 8
2 * (3 + 2) = 10, car dans ce cas on fait d’abord 3 + 2 = 5 et ensuite on fait la parenthèse * 2 = 10.

Exemple de parenthèse:

if((x < 4) && ((y > 2) || (z = 0))) { Ce qui sera exécuté si le résultat des tests sont juste } else { Ce qui sera exécuté si le résultat des tests sont faux }

Dans notre cas le programme vérifie si y est supérieur à 2 ou que z est égal à 0. Si aucune des conditions est remplie, il exécutera le else, si au moins une des conditions est remplie il vérifiera si x est inférieur à 4 et s'il ne l'est pas il exécutera le else, cependant si x est bien inférieur a 4 il exécutera les instructions saisies en dessous du if}.

Nous avions vu que si le résultat du test du if était faux le programme effectuait le else cependant nous pouvons rajouter un if au else , je m'explique avec un exemple.
Exemple de else if:

if((x < 4) && (y > 2))
{
/* Ce qui sera exécuté si le résultat des tests (x < 4) && (y > 2) sont juste même si i est supérieur à 45 */
)
else if(i < 45)
{
/* Ce qui sera exécuté si le résultat des tests (x < 4) && (y > 2)est faux 
mais que le résultat du test (i< 45) est juste */
)
else
{
/* Ce qui sera exécuté si le résultat des tests (x<4)&&(y>2)est faux 
 et que le résultat du test  (i < 45) est faux */
}

Structures Switch

Introduction Switch

Le Switch pourrait s’apparenter à une suite d'instruction if else, il ne s'utilise pas de la même manière mais permet de faire exactement la même chose.

Cependant, il y a deux différences principales :

• la structure switch est plus simple d’utilisation car le test n’est pas entièrement répété,
• l'exécution est plus rapide qu'une suite d'instruction if else.

Structure Switch

Voici un exemple qui vous parlera sûrement mieux que des milliers d'explications.

int toto = 1;
switch (toto)
{
    case 1: 
        Console.WriteLine("la valeur de toto est 1");
        break;
    case 2:
        Console.WriteLine("la valeur de toto est 2");
        break;
    default:
        Console.WriteLine("la valeur de toto n'est ni 1 ni 2");
        break;
}

Comme vous avez pu le constater, la valeur qui suit un case est la valeur à laquelle toto sera comparé et elle correspond, toutes les instructions à partir de l'instruction case sont effectuées jusqu'à la fin du switch ou la prochaine instruction break.

Il est possible de regrouper plusieurs instructions case pour effectuer le même traitement.

Exemple :

int toto = 1;
switch (toto)
{
    case 1: 
    case 2:
        Console.WriteLine("la valeur de toto est 1 ou 2");
        break;
    default:
        Console.WriteLine("la valeur de toto n'est ni 1 ni 2");
        break;
}

Il n'est toutefois pas possible de ne pas terminer les instructions de traitement afin de poursuivre avec le cas suivant :

int toto = 1;
switch (toto)
{
    case 1:
        Console.WriteLine("la valeur de toto est 1, et on continue ...");
        // Le compilateur exige une instruction de fin de cas
    case 2:
        Console.WriteLine("la valeur de toto est 1 ou 2");
        break;
    default:
        Console.WriteLine("la valeur de toto n'est ni 1 ni 2");
        break;
}

La poursuite d'instructions de traitement d'un autre cas doit être indiquée explicitement avec l'instruction goto :

int toto = 1;
switch (toto)
{
    case 1:
        Console.WriteLine("la valeur de toto est 1, et on continue ...");
        goto case 2;
    case 2:
        Console.WriteLine("la valeur de toto est 1 ou 2");
        break;
    default:
        Console.WriteLine("la valeur de toto n'est ni 1 ni 2");
        break;
}

Boucles

While

Introduction While

While est une boucle simple qui vas exécuter les commandes temps que la condition est évalué TRUE

Structure While

while(condition)
{
    commandes
}

Do While

Introduction Do While

Do While est légèrement différente de While car la condition se situe après la boucle et se finit obligatoirement pas un ";" . Si la condition est évaluée a FALSE, la boucle sera tout de même exécutée une fois.

Structure Do While

do
{
    commandes
}
while (condition);

For

Introduction For

Les boucles for sont des boucles "complexes".

Initialisation est évalué au début de la boucle puis condition est à son tour évalué (début d'une l'itération), si elle vaut TRUE alors la boucle continue et commandes est exécuté, si elle vaut FALSE la boucle s’arrête là. À la fin de chaque itération incrémentation est évalué (exécution).

Les "expressions" peuvent être laissé vide, mais l'instruction break; doit être utilisé pour sortir de la boucle.

Structure For

for(initialisation;condition;incrémentation)
{
    commandes
}

for(;;)
{
    commandes
    break;
}

boucle de recherche : for (initialisation;condition;incrémentation);