'>

Les instructions de contrôle du déroulement du programme dans C-sharp

1.4.1 Arrêt
  
La méthode Exit définie dans la classe Environment permet d'arrêter l'exécution d'un programme.
syntaxe void Exit(int status)
action arrête le processus en cours et rend la valeur status au processus père
Exit provoque la fin du processus en cours et rend la main au processus appelant. La valeur de status peut être utilisée par celui-ci.
Sous DOS, cette variable status est rendue dans la variable système ERRORLEVEL dont la valeur peut être testée dans un fichier
batch. Sous Unix, avec l'interpréteur de commandes Shell Bourne, c'est la variable $? qui récupère la valeur de status.
Environment.Exit(0);

arrêtera l'exécution du programme avec une valeur d'état à 0.
1.4.2 Structure de choix simple
 syntaxe :  if (condition) {actions_condition_vraie;} else {actions_condition_fausse;}
notes:
• la condition est entourée de parenthèses.
• chaque action est terminée par point-virgule.
• les accolades ne sont pas terminées par point-virgule.
• les accolades ne sont nécessaires que s'il y a plus d'une action.
• la clause else peut être absente.
• il n'y a pas de clause then.
L'équivalent algorithmique de cette structure est la structure si .. alors … sinon :
si condition
alors actions_condition_vraie
sinon actions_condition_fausse
finsi
exemple
if (x>0)  { nx=nx+1;sx=sx+x;} else dx=dx-x;
On peut imbriquer les structures de choix :
if(condition1)
if (condition2)
{......}
   else  //condition2
      {......}
else  //condition1
 {.......}
Se pose parfois le problème suivant :
1. using System;
2.
3. namespace Chap1 {
4. class P07 {
5. static void Main(string[] args) {
6. int n = 5;
7. if (n > 1)
8. if (n > 6)
9. Console.Out.WriteLine(">6");
10. else Console.Out.WriteLine("<=6");
11. }
12. }
13.}
Dans l'exemple précédent, le else de la ligne 10 se rapporte à quel if ? La règle est qu'un else se rapporte toujours au if le plus proche :
if(n>6), ligne 8, dans l'exemple. Considérons un autre exemple :
1. if (n2 > 1) {
2. if (n2 > 6) Console.Out.WriteLine(">6");
3.        } else Console.Out.WriteLine("<=1");
Ici nous voulions mettre un else au if(n2>1) et pas de else au if(n2>6). A cause de la remarque précédente, nous sommes obligés de
mettre des accolades au if(n2>1) {...} else ...

1.4.3 Structure de cas
La syntaxe est la suivante :
switch(expression) {
case v1:
actions1;
break;
case v2: 
actions2;
break;
 . .. .. .. .. ..
default: 
actions_sinon;
break;
}
notes
• la valeur de l'expression de contrôle du switch peut être un entier, un caractère, une chaîne de caractères
• l'expression  de contrôle est entourée de parenthèses.
• la clause default peut être absente.
• les valeurs v
i
 sont des valeurs possibles de l'expression. Si l'expression a pour valeur v
i
, les actions derrière la clause case vi
sont exécutées.
• l'instruction break fait sortir de la structure de cas.
• chaque bloc d'instructions lié à une valeur v
i
doit se terminer par une instruction de branchement (break, goto, return, ...)
sinon le compilateur signale une erreur.
exemple
En  algorithmique
                selon la valeur de choix
                    cas 0
                         fin du module
                    cas 1
                         exécuter module M1
                    cas 2
                        exécuter module M2
                    sinon
                         erreur<--vrai
                findescas
En C#
1. int choix = 2;
2. bool erreur = false;
3. switch (choix) {
4. case 0: return;
5. case 1: M1(); break;
6. case 2: M2(); break;
7. default: erreur = true; break;
8. }
9. }// fin Main
10.
11. static void M1() {
12. Console.WriteLine("M1");
13. }
14.
15. static void M2() {
16. Console.WriteLine("M2");
17. }
18.}

1.4.4 Structures de répétition
1.4.4.1 Nombre de répétitions connu
Structure for
La syntaxe est la suivante :
for (i=id;i<=if;i=i+ip){ 
    actions;
   }
Notes
• les 3 arguments du for sont à l'intérieur d'une parenthèse et séparés par des points-virgules.
• chaque action du for est terminée par un point-virgule.
• l'accolade n'est nécessaire que s'il y a plus d'une action.
• l'accolade n'est pas suivie de point-virgule.
L'équivalent algorithmique est la structure pour :
pour i variant de id à if avec un pas de ip
actions
finpour
qu'on peut traduire par une structure tantque :
i  id
tantque i<=if
actions
i i+ip
fintantque
Structure foreach
La syntaxe est la suivante :
foreach (Type variable in collection)
instructions;
}
Notes
• collection est une collection d'objets énumérable. La collection d'objets énumérable que nous connaissons déjà est le tableau
• Type est le type des objets de la collection. Pour un tableau, ce serait le type des éléments du tableau
• variable est une variable locale à la boucle qui va prendre successivement pour valeur, toutes les valeurs de la collection.
Ainsi le code suivant :
1. string[] amis = { "paul", "hélène", "jacques", "sylvie" };
2. foreach (string nom in amis) {
3. Console.WriteLine(nom);
4.          }
afficherait :
paul
hélène
jacques
sylvie
1.4.4.2 Nombre de répétitions inconnu
Il existe de nombreuses structures en C# pour ce cas.
Structure tantque (while)
while(condition){
       actions;
}
On boucle tant que la condition est vérifiée. La boucle peut ne jamais être exécutée.
notes:
• la condition est entourée de parenthèses.
• chaque action est terminée par point-virgule.
• l'accolade n'est nécessaire que s'il y a plus d'une action.
• l'accolade n'est pas suivie de point-virgule.
La structure algorithmique correspondante est la structure tantque :
tantque condition
actions
fintantque
Structure répéter jusqu'à (do while)
La syntaxe est la suivante :
do{
    instructions;
}while(condition);
On boucle jusqu'à ce que la condition devienne fausse. Ici la boucle est faite au moins une fois.
notes
• la condition est entourée de parenthèses.
• chaque action est terminée par point-virgule.
• l'accolade n'est nécessaire que s'il y a plus d'une action.
• l'accolade n'est pas suivie de point-virgule.
La structure algorithmique correspondante est la structure répéter … jusqu'à :
répéter
actions
jusqu'à condition
Structure pour générale (for)
La syntaxe est la suivante :
for(instructions_départ;condition;instructions_fin_boucle){
instructions;
}
On boucle tant que la condition est vraie (évaluée avant chaque tour de boucle). Instructions_départ sont effectuées avant d'entrer
dans la boucle pour la première fois. Instructions_fin_boucle sont exécutées après chaque tour de boucle.
notes
• les différentes instructions dans instructions_depart et instructions_fin_boucle sont séparées par des virgules.
La structure algorithmique correspondante est la suivante :
instructions_départ
tantque condition
actions
instructions_fin_boucle
fintantque
Exemples
Les fragments de code suivants calculent tous la somme des 10 premiers nombres entiers.

1. int i, somme, n=10;
2. for (i = 1, somme = 0; i <= n; i = i + 1)
3. somme = somme + i;
4.
5. for (i = 1, somme = 0; i <= n; somme = somme + i, i = i + 1) ;
6.
7. i = 1; somme = 0;
8. while (i <= n) { somme += i; i++; }
9.
10. i = 1; somme = 0;
11. do somme += i++;
12. while (i <= n);
13.
1.4.4.3 Instructions de gestion de boucle
break
fait sortir de la boucle for, while, do ... while.
continue
fait passer à l'itération suivante des boucles for, while, do ... while

Publié par Drupal french Study