'>

Structures de contrôle C plus plus

 Un programme est en général pas limitée à une séquence linéaire d'instructions. Au cours de son processus, il peut bifurquer, répéter le code ou prendre des décisions. Pour ce faire, C + + fournit des structures de contrôle qui servent à préciser ce qui doit être fait par notre programme, quand et dans quelles circonstances.

Avec l'introduction de structures de contrôle, nous allons avoir à introduire un nouveau concept: le composé instruction ou un bloc. Un bloc est un groupe d'instructions qui sont séparés par des points virgules (;) comme toutes les déclarations + + C, mais regroupées en un bloc entre accolades: {}:

{Statement1; statement2; statement3;}

La plupart des structures de contrôle que nous allons voir dans cette section nécessitent une déclaration générique dans le cadre de sa syntaxe. Une déclaration peut être soit une simple déclaration (une simple instruction se termine par un point-virgule) ou une instruction composée (plusieurs instructions regroupées en un bloc), comme nous venons de décrire. Dans le cas que nous voulons que la déclaration soit une simple déclaration, nous n'avons pas besoin de l'enfermer dans des accolades ({}). Mais dans le cas que nous voulons que la déclaration soit une déclaration composé il doit être placé entre accolades ({}), formant un bloc.

Structure conditionnelle: if et else
Le mot-clé if est utilisée pour exécuter une instruction ou un bloc seulement si une condition est remplie. Sa forme est:

if (condition) déclaration

Où condition est l'expression qui est en cours d'évaluation. Si cette condition est vraie, instruction est exécutée. Si elle est fausse, la déclaration est ignorée (non exécutée) et le programme continue juste après cette structure conditionnelle.
Par exemple, le fragment de code suivant imprime x 100 est que si la valeur stockée dans la variable x est en effet 100:

1
 2


  

 if (x == 100) cout << "x is 100" ;



Si nous voulons plus d'une seule instruction à exécuter dans le cas où la condition est vraie, nous pouvons spécifier un bloc en utilisant des accolades {}:

 1
 2
 3
 4
 5


  

 if (x == 100) { cout << "x is " ; cout << x; }



Nous pouvons en outre préciser ce que nous voulons arriver si la condition n'est pas remplie en utilisant le mot-clé d'autre. Sa forme est utilisé en conjonction avec le cas est:

if (condition) statement1 autre statement2

Par exemple:

 1
 2
 3
 4


  

 if (x == 100) cout << "x is 100" ; else cout << "x is not 100" ;



impressions sur l'écran est de 100 x si x est en effet une valeur de 100, mais si ce n'est pas-et seulement si-non il imprime x n'est pas 100.

Le cas + structures d'autre ne peut être concaténées avec l'intention de vérifier une plage de valeurs. L'exemple suivant montre l'utilisation disant que si la valeur actuellement stockée dans x est positif, négatif ou aucun d'entre eux (soit zéro):

 1
 2
 3
 4
 5
 6


  

 if (x > 0) cout << "x is positive" ; else if (x < 0) cout << "x is negative" ; else cout << "x is 0" ;



Rappelez-vous que dans le cas que nous voulons plus d'une seule instruction à exécuter, il faut les regrouper dans un bloc en les enfermant dans des accolades {}.

structures d'itération (boucles)

Les boucles ont pour but de répéter une déclaration d'un certain nombre de fois ou tant qu'une condition est remplie.

La boucle while
Son format est le suivant:

while (expression)

et sa fonctionnalité est tout simplement de répéter déclaration alors que la condition énoncée dans l'expression est vraie.
Par exemple, nous allons faire un programme à l'aide d'un compte à rebours boucle while:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19


  

 // custom countdown using while #include <iostream> using namespace std; int main () { int n; cout << "Enter the starting number > " ; cin >> n; while (n>0) { cout << n << ", " ; --n; } cout << "FIRE!\n" ; return 0; }

  

  Entrez le numéro de départ> 8
  8, 7, 6, 5, 4, 3, 2, 1, FEU!



Lorsque le programme démarre l'utilisateur est invité à insérer un numéro de départ pour le compte à rebours. Puis la boucle tant que commence, si la valeur entrée par l'utilisateur satisfait à la condition n> 0 (ce que n est supérieur à zéro) du bloc qui suit la condition sera exécuté et répété tant que la condition (n> 0) reste étant vrai.

L'ensemble du processus du programme précédent peut être interprétée selon le script suivant (à partir de principal):

    L'utilisateur attribue une valeur à n
    La condition de tout est vérifié (n> 0). A ce stade, il ya deux possibilités:
    * Condition est vraie: instruction est exécutée (à l'étape 3)
    * Condition est fausse: ignorer déclaration et continuer après (à l'étape 5)
    Exécuter l'instruction:
    cout << n << ",";
    - N;
    (Affiche la valeur de n à l'écran et diminue par n 1)
    Fin de bloc. Reviendra automatiquement à l'étape 2
    Poursuivre le programme juste après le bloc: FIRE d'impression! et la fin du programme.


Lors de la création d'une boucle while, nous devons toujours considérer qu'il doit se terminer à un moment donné, nous devons donc fournir dans le bloc une méthode pour forcer la condition pour devenir fausse à un moment donné, sinon la boucle continuera en boucle pour toujours. Dans ce cas, nous avons inclus - n; qui diminue la valeur de la variable qui est en cours d'évaluation dans l'état (n) par un - ce qui finira par faire de la condition (n> 0) pour devenir fausse après un certain nombre de boucle itérations: pour être plus précis, lorsque n est 0, c'est là que notre boucle while et notre fin de compte à rebours.

Bien sûr, cela est une action simple pour notre ordinateur que tout le compte à rebours est effectuée instantanément sans aucun retard pratique entre les numéros.

La boucle do-while

Son format est le suivant:

faire déclaration while (condition);

Sa fonctionnalité est exactement la même que la boucle while, sauf que condition dans la boucle do-while est évaluée après l'exécution de la déclaration au lieu d'avant, accordant au moins une exécution de la déclaration, même si la condition n'est jamais remplie. Par exemple, le programme d'exemple suivant fait écho à un nombre quelconque saisi jusqu'à ce que vous entrez 0.

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15


  

 // number echoer #include <iostream> using namespace std; int main () { unsigned long n; do { cout << "Enter number (0 to end): " ; cin >> n; cout << "You entered: " << n << "\n" ; } while (n != 0); return 0; }

  

  Entrez le numéro (0 à la fin): 12345
  Vous avez saisi: 12345
  Entrez le numéro (0 à la fin): 160277
  Vous avez saisi: 160277
  Entrez le numéro (0 à la fin): 0
  Vous avez saisi: 0



La boucle do-while est généralement utilisé lorsque la condition qui doit déterminer la fin de la boucle est déterminée dans la déclaration de la boucle elle-même, comme dans le cas précédent, où l'entrée de l'utilisateur dans le bloc est ce qui est utilisé pour déterminer si la boucle a à la fin. En fait, si vous ne saisissez la valeur 0 dans l'exemple précédent, vous pouvez être invité à entrer d'autres numéros pour toujours.

La boucle for

Son format est le suivant:

pour (initialisation; condition; augmentation) déclaration;

et sa fonction principale est de répéter déclaration tant que la condition reste vraie, comme la boucle while. Mais en plus, la boucle pour fournit des emplacements spécifiques pour contenir une déclaration d'initialisation et une déclaration d'augmentation. Donc, cette boucle est spécialement conçu pour effectuer une action répétitive avec un compteur qui est initialisé et a augmenté à chaque itération.

Il fonctionne de la manière suivante:

    l'initialisation est exécutée. Généralement, il s'agit d'un réglage initial de valeur pour une variable compteur. Ce n'est exécutée qu'une fois.
    condition est vérifiée. S'il est vrai que la boucle se poursuit, sinon la boucle se termine et la déclaration est ignorée (non exécuté).
    instruction est exécutée. Comme d'habitude, il peut s'agir d'une simple déclaration ou un bloc entre accolades {}.
    enfin, tout ce qui est spécifié dans le champ augmentation est exécutée et la boucle revient à l'étape 2.


Voici un exemple de compte à rebours à l'aide d'une boucle for:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11


  

 // countdown using a for loop #include <iostream> using namespace std; int main () { for ( int n=10; n>0; n--) { cout << n << ", " ; } cout << "FIRE!\n" ; return 0; }

  

  10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FEU!



Les champs d'initialisation et augmentation sont facultatifs. Ils peuvent rester vide, mais dans tous les cas, les signes de point-virgule entre eux doit être écrit. Par exemple, nous pourrions écrire: for (; n <10 ;) si nous voulions préciser aucune initialisation et aucune augmentation, ou pour (; n <10, n + +) si nous voulions inclure un champ d'augmentation, mais aucune initialisation (peut-être parce que l' variable a été déjà initialisé avant).

En option, en utilisant l'opérateur virgule (,) nous pouvons spécifier plus d'une expression dans l'un des champs inclus dans une boucle, comme dans l'initialisation, par exemple. L'opérateur virgule (,) est un séparateur d'expression, il sert à séparer plus d'une expression où un seul est généralement attendu. Par exemple, supposons que nous voulions pour initialiser plus d'une variable dans notre boucle:

 1
 2
 3
 4


  

 for ( n=0, i=100 ; n!=i ; n++, i-- ) { // whatever here... }



Cette boucle sera exécuté pendant 50 heures si aucun n ou i sont modifiés dans la boucle:


n commence par la valeur 0, et i avec 100, la condition est n! = i (que n n'est pas égal à i). Parce que n est augmentée par un et i ont diminué de un, l'état de la boucle va devenir fausse après la boucle 50e, lorsque n et i sera égal à 50.

Aller déclarations.

L'instruction break

Utilisation de pause, nous pouvons laisser une boucle même si la condition de son extrémité n'est pas remplie. Il peut être utilisé pour mettre fin à une boucle infinie, ou de le forcer à mettre fin avant son terme naturel. Par exemple, nous allons arrêter le compte à rebours avant sa fin naturelle (peut-être en raison d'une défaillance de contrôle du moteur?):

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19


  

 // break loop example #include <iostream> using namespace std; int main () { int n; for (n=10; n>0; n--) { cout << n << ", " ; if (n==3) { cout << "countdown aborted!" ; break ; } } return 0; }

  

  10, 9, 8, 7, 6, 5, 4, 3, compte à rebours interrompu!



L'instruction continue

L'instruction continue provoque le programme d'ignorer le reste de la boucle dans l'itération courante comme si la fin du bloc d'instruction avait été atteint, l'amenant à passer au début de l'itération suivante. Par exemple, nous allons sauter le numéro 5 dans notre compte à rebours:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13


  

 // continue loop example #include <iostream> using namespace std; int main () { for ( int n=10; n>0; n--) { if (n==5) continue ; cout << n << ", " ; } cout << "FIRE!\n" ; return 0; }

  

  10, 9, 8, 7, 6, 4, 3, 2, 1, FEU!



L'instruction goto
goto permet de faire un saut absolu à un autre point du programme. Vous devriez utiliser cette fonction avec précaution car son exécution provoque un saut inconditionnel ignorant tout type de limitations de nidification.
Le point de destination est identifié par une étiquette, qui est ensuite utilisée comme un argument pour l'instruction goto. Une étiquette est constitué d'un identifiant valide suivi de deux points (:).

De manière générale, cette instruction a aucune utilité concrète dans la programmation structurée ou orientée objet en dehors de celles que les fans de programmation de bas niveau peuvent trouver pour elle. Par exemple, voici notre boucle de compte à rebours en utilisant goto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15


  

 // goto loop example #include <iostream> using namespace std; int main () { int n=10; loop: cout << n << ", " ; n--; if (n>0) goto loop; cout << "FIRE!\n" ; return 0; }

  

  10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FEU!



La fonction de sortie

sortie est une fonction définie dans la bibliothèque cstdlib.

Le but de la sortie est de mettre fin au programme en cours avec un code de sortie spécifique. Son prototype est:



  

 void exit ( int exitcode);



Le code de sortie est utilisée par certains systèmes d'exploitation et peut être utilisé par les programmes d'appel. Par convention, un code de sortie de 0 signifie que le programme a pris fin normalement et toute autre valeur signifie que certaines erreurs ou des résultats inattendus se sont produits.

La structure sélective: commutateur.
La syntaxe de l'instruction switch est un peu particulier. Son objectif est de vérifier plusieurs valeurs constantes possibles pour une expression. Quelque chose de semblable à ce que nous avons fait au début de cette section avec la concaténation de plusieurs cas et else if instructions. Sa forme est la suivante:

 commutateur (expression)
 {
   cas constante1:
      groupe d'instructions 1;
      break;
   cas constante2:
      groupe des états 2;
      break;
   .
   .
   .
   par défaut:
      groupe par défaut des états
 }


Il fonctionne de la manière suivante: switch évalue expression et vérifie si elle est équivalente à constante1, si c'est le cas, il exécute un groupe d'instructions 1 jusqu'à ce qu'il trouve l'instruction break. Quand il trouve cette déclaration de pause le programme saute à la fin de la structure sélective de l'interrupteur.

Si l'expression n'était pas égal à constante1 il sera vérifié contre constante2. Si elle est égale à cela, il exécutera groupe des états 2 jusqu'à ce qu'un mot-clé break est trouvé, puis passera à la fin de la structure sélective de l'interrupteur.

Enfin, si la valeur d'expression ne correspond pas à l'une des constantes définies précédemment (vous pouvez inclure autant d'étiquettes de cas que les valeurs que vous souhaitez vérifier), le programme va exécuter les instructions figurant après le défaut: étiquette, si elle existe (depuis il est facultatif).

Les deux fragments de code suivants ont le même comportement:

passer exemple     if-else équivalent

 commutateur (x) {
   case 1:
     cout << "x est 1";
     break;
   case 2:
     cout << "x est égal à 2";
     break;
   par défaut:
     cout << "valeur de x inconnu";
   }

  

 si (x == 1) {
   cout << "x est 1";
   }
 else if (x == 2) {
   cout << "x est égal à 2";
   }
 else {
   cout << "valeur de x inconnu";
   }


L'instruction switch est un peu particulière dans le langage C + +, car il utilise des étiquettes au lieu de blocs. Cela nous oblige à mettre l'instruction break après que le groupe de déclarations que nous voulons être exécuté pour un état ​​spécifique. Sinon le reste des déclarations, y compris celles correspondant à d'autres labels, sera également exécuté jusqu'à la fin du bloc de commutation sélective ou une déclaration de rupture est atteint.

Par exemple, si nous n'avons pas inclus une instruction break après le premier groupe de cas-ci, le programme ne passera automatiquement à la fin du bloc sélectif du commutateur et il continuera à exécuter le reste des états jusqu'à ce qu'il atteigne soit une instruction de pause ou la fin du bloc de commutation sélective. Cela rend inutile d'inclure les accolades {} entourant les déclarations de chacun des cas, et il peut également être utile pour exécuter le même bloc d'instructions pour différentes valeurs possibles pour l'expression en cours d'évaluation. Par exemple:

 1
 2
 3
 4
 5
 6
 7
 8
 9


  

 switch (x) { case 1: case 2: case 3: cout << "x is 1, 2 or 3" ; break ; default : cout << "x is not 1, 2 nor 3" ; }



Notez que le commutateur ne peut être utilisé pour comparer une expression contre constantes. Par conséquent, nous ne pouvons pas mettre les variables que des labels (par exemple cas n: où n est une variable) ou plages (cas (1 .. 3):) parce qu'ils ne sont pas C + + valide constantes.

Si vous avez besoin de vérifier les plages ou les valeurs qui ne sont pas constantes, utiliser un enchaînement de if et else if.
Publié par Drupal Study