Instructions et flux de contrĂ´le


Une instruction C ++ simple est chacune des instructions individuelles d’un programme, comme les dĂ©clarations de variable et les expressions vues dans les sections prĂ©cĂ©dentes. Ils se terminent toujours par un point-virgule (;) et sont exĂ©cutĂ©s dans le mĂªme ordre dans lequel ils apparaissent dans un programme.

Mais les programmes ne se limitent pas Ă  une sĂ©quence d’instructions linĂ©aire. Au cours de son processus, un programme peut rĂ©pĂ©ter des segments de code, ou prendre des dĂ©cisions et se bifurquer. Ă€ cette fin, C ++ fournit des instructions de contrĂ´le de flux permettant de spĂ©cifier ce que doit faire notre programme, quand et dans quelles circonstances.

De nombreuses instructions de contrĂ´le de flux expliquĂ©es dans cette section nĂ©cessitent une instruction gĂ©nĂ©rique dans le cadre de sa syntaxe. Cette instruction peut Ăªtre une simple instruction C ++, telle qu’une seule instruction, terminĂ©e par un point-virgule (;), ou une instruction composĂ©e. Une instruction composĂ©e est un groupe d’instructions (chacune d’entre elles terminĂ©e par son propre point-virgule), mais toutes regroupĂ©es dans un bloc, entourĂ©es d’accolades: {}:

{instruction1; instruction2; instruction3;}

Le bloc entier est considĂ©rĂ© comme une seule instruction (composĂ© de plusieurs sous-instructions). Chaque fois qu’une instruction gĂ©nĂ©rique fait partie de la syntaxe d’une instruction de contrĂ´le de flux, il peut s’agir d’une instruction simple ou composĂ©e.

Déclarations de sélection: if et else

Le mot-clé if est utilisé pour exécuter une instruction ou un bloc si et seulement si une condition est remplie. Sa syntaxe est la suivante:

if  (condition) déclaration

Ici, condition est l’expression en cours d’Ă©valuation. Si cette condition est vraie, l’instruction est exĂ©cutĂ©e. S’il est faux, l’instruction n’est pas exĂ©cutĂ©e (elle est simplement ignorĂ©e) et le programme continue immĂ©diatement après l’instruction de sĂ©lection complète.

Par exemple, le fragment de code suivant imprime le message (x = 100), uniquement si la valeur stockée dans la variable x est bien 100:

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

Si x n’est pas exactement 100, cette instruction est ignorĂ©e et rien n’est imprimĂ©.

Si vous souhaitez inclure plusieurs instructions Ă  exĂ©cuter lorsque la condition est remplie, ces instructions doivent Ăªtre placĂ©es entre accolades ({}), formant un bloc:

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

Comme d’habitude, l’indentation et les sauts de ligne dans le code n’ont aucun effet. Le code ci-dessus est donc Ă©quivalent Ă :

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

Les instructions de sĂ©lection avec if peuvent Ă©galement spĂ©cifier ce qui se passe lorsque la condition n’est pas remplie, en utilisant le mot clĂ© else pour introduire une instruction alternative. Sa syntaxe est la suivante:

if (condition) instruction1 else instruction2

oĂ¹ instruction1 est exĂ©cutĂ© dans le cas oĂ¹ la condition est vraie et dans le cas contraire, instruction2 est exĂ©cutĂ©.

Par exemple:

if (x == 100)
  cout << "x est 100";
else
  cout << "x n'est pas 100";

Ceci imprime x est 100, si x a effectivement une valeur de 100, mais si ce n’est pas le cas, et seulement si ce n’est pas le cas, x est différent de 100.

Plusieurs structures if + else peuvent Ăªtre concatĂ©nĂ©es dans le but de vĂ©rifier une plage de valeurs. Par exemple:

if (x> 0)
  cout << "x est positif";
else if (x <0)
  cout << "x est négatif";
else
  cout << "x est 0";

Ceci affiche si x est positif, nĂ©gatif ou nul en concatĂ©nant deux structures if-else. LĂ  encore, il aurait Ă©galement Ă©tĂ© possible d’exĂ©cuter plus d’une instruction par cas en les regroupant dans des blocs entre accolades: {}.

Instruction d’itĂ©ration (les boucles)

Les boucles répètent une déclaration un certain nombre de fois ou pendant qu’une condition est remplie. Ils sont introduits par les mots-clés while, do et for.

La boucle while

Le type de boucle le plus simple est la boucle while. Sa syntaxe est la suivante:

While (expression) instructions

La boucle while rĂ©pète simplement l’instruction tant que expression est vraie. Si, après l’exĂ©cution d’une instruction, expression n’est plus vraie, la boucle se termine et le programme continue juste après la boucle. Par exemple, regardons un compte Ă  rebours en utilisant une boucle while:

// compte à rebours personnalisé en utilisant while
#include <iostream>
using namespace std;

int main ()
{
  int n = 10;

  while (n> 0) {
    cout << n << ",";
    --n;
  }

  cout << "décollage! \ n";
}

La première instruction de main donne n la valeur 10. Il s’agit du premier nombre du compte à rebours. La boucle while commence alors: si cette valeur remplit la condition n> 0 (que n est supérieur à zéro), le bloc qui suit la condition est exécuté et répété tant que la condition (n> 0) reste en cours vrai.

L’ensemble du processus du programme prĂ©cĂ©dent peut Ăªtre interprĂ©tĂ© selon le script suivant (commençant par main):

  • n se voit attribuer une valeur
  • La condition while est vĂ©rifiĂ©e (n> 0). Ă€ ce stade, il y a deux possibilitĂ©s:
    la condition est vraie: l’instruction est exĂ©cutĂ©e
    la condition est fausse: ignore l’instruction et continue après
    Executer l’instruction:
    cout << n << « , »;
    –n;
    (affiche la valeur de n et diminue n de 1)
  • Fin du bloc. Revenez automatiquement Ă  l’Ă©tape 2.
  • Continuez le programme juste après le bloc:
    imprimer décollage! et terminer le programme.

Une chose Ă  considĂ©rer avec les boucles While est que la boucle doit se terminer Ă  un moment donnĂ©. Par consĂ©quent, la dĂ©claration doit modifier les valeurs vĂ©rifiĂ©es dans la condition d’une manière ou d’une autre, de manière Ă  forcer celle-ci Ă  devenir fausse Ă  un moment donnĂ©. Sinon, la boucle continuera Ă  boucler pour toujours. Dans ce cas, la boucle inclut –n, qui diminue de un la valeur de la variable Ă©valuĂ©e dans la condition (n) – elle finira par rendre la condition (n> 0) fausse après un certain nombre d’itĂ©rations de boucle. Pour Ăªtre plus prĂ©cis, après 10 itĂ©rations, n devient 0, ce qui rend la condition non plus vraie et met fin Ă  la boucle while.

Ă€ lire aussi  Abstraction en C++ avec exemples

Notez que la complexité de cette boucle est triviale pour un ordinateur et que tout le compte à rebours est effectué instantanément, sans délai pratique entre les éléments du compte (si cela vous intéresse, voir sleep_for pour un exemple de compte à rebours avec retards).

La boucle do-while

Une boucle très similaire est la boucle do-while, dont la syntaxe est la suivante:

do instructions while (condition);

Il se comporte comme une boucle while, sauf que la condition est Ă©valuĂ©e après l’exĂ©cution de l’instruction au lieu d’avant, garantissant au moins une exĂ©cution de l’instruction, mĂªme si la condition n’est jamais remplie. Par exemple, l’exemple de programme suivant reprend n’importe quel texte introduit par l’utilisateur jusqu’Ă  ce que l’utilisateur entre au revoir:

// echo machine
#include <iostream>
#include <string>
using namespace std;

int main ()
{
  string str;
  do {
    cout << "Saisir le texte:";
    getline (cin, str);
    cout << "Vous avez entré:" << str << '\ n';
  } while (str! = "au revoir");
}

Résultat de l’exécution :

Saisir le texte: bonjour
Vous avez entré: bonjour
Saisir le texte: qui est lĂ ?
Vous avez entré: qui est là?
Saisir le texte: au revoir
Vous avez entré: au revoir

La boucle do-while est gĂ©nĂ©ralement prĂ©fĂ©rĂ©e Ă  une boucle while lorsque l’instruction doit Ăªtre exĂ©cutĂ©e au moins une fois, par exemple lorsque la condition vĂ©rifiĂ©e jusqu’Ă  la fin de la boucle est dĂ©terminĂ©e dans l’instruction de boucle elle-mĂªme. Dans l’exemple prĂ©cĂ©dent, l’entrĂ©e de l’utilisateur dans le bloc dĂ©termine ce qui permet de dĂ©terminer si la boucle se termine. Et ainsi, mĂªme si l’utilisateur veut terminer la boucle le plus tĂ´t possible en entrant au revoir, le bloc de la boucle doit Ăªtre exĂ©cutĂ© au moins une fois pour demander une entrĂ©e et la condition ne peut, en fait, Ăªtre dĂ©terminĂ©e qu’après. est exĂ©cutĂ©.

La boucle for

La boucle for est conçue pour itérer un certain nombre de fois. Sa syntaxe est la suivante:

for (initialisation; condition; augmentation) instruction;

Comme la boucle while, cette boucle rĂ©pète l’instruction tant que la condition est vraie. Mais, en outre, la boucle for fournit des emplacements spĂ©cifiques contenant une expression d’initialisation et d’augmentation, exĂ©cutĂ©es respectivement avant le dĂ©but de la boucle et après chaque itĂ©ration. Par consĂ©quent, il est particulièrement utile d’utiliser des variables de compteur comme condition.

Cela fonctionne de la manière suivante:

  • l’initialisation est exĂ©cutĂ©e. GĂ©nĂ©ralement, cela dĂ©clare une variable de compteur et lui attribue une valeur initiale. Ceci est exĂ©cutĂ© une seule fois, au dĂ©but de la boucle.
  • la condition est vĂ©rifiĂ©e. Si c’est vrai, la boucle continue; sinon, la boucle se termine et l’instruction est ignorĂ©e.
  • l’instruction est exĂ©cutĂ©e. Comme d’habitude, il peut s’agir d’une simple instruction ou d’un bloc entourĂ© d’accolades {}.
  • L’augmentation est exĂ©cutĂ©e et la boucle revient Ă  l’Ă©tape 2.
  • la boucle se termine: l’exĂ©cution se poursuit par l’instruction suivante.

Voici l’exemple de compte Ă  rebours utilisant une boucle for:

// compte Ă  rebours Ă  l'aide d'une boucle for
#include <iostream>
using namespace std;

int main ()
{
  for (int n = 10; n> 0; n--) {
    cout << n << ",";
  }
  cout << "décollage! \ n";
}

Les trois champs d’une boucle for sont optionnels. Ils peuvent Ăªtre laissĂ©s vides, mais dans tous les cas, les points-virgules entre eux sont obligatoires. Par exemple, for (; n <10;) est une boucle sans initialisation ni augmentation (Ă©quivalent Ă  une boucle while); et pour (; n <10; ++ n) est une boucle avec augmentation, mais aucune initialisation (peut-Ăªtre parce que la variable a dĂ©jĂ  Ă©tĂ© initialisĂ©e avant la boucle). Une boucle sans condition Ă©quivaut Ă  une boucle dont la condition est vraie (c’est-Ă -dire une boucle infinie).

Étant donnĂ© que chacun des champs est exĂ©cutĂ© Ă  un moment particulier du cycle de vie d’une boucle, il peut Ăªtre utile d’exĂ©cuter plus d’une expression unique que par une initialisation, une condition ou une instruction. Malheureusement, ce ne sont pas des dĂ©clarations, mais plutĂ´t des expressions simples et ne peuvent donc pas Ăªtre remplacĂ©es par un bloc. En tant qu’expressions, ils peuvent toutefois utiliser l’opĂ©rateur de virgule (,): cet opĂ©rateur est un sĂ©parateur d’expression et peut sĂ©parer plusieurs expressions lorsqu’un seul est gĂ©nĂ©ralement attendu. Par exemple, en l’utilisant, il serait possible Ă  une boucle for de gĂ©rer deux variables de compteur, en les initialisant et en les augmentant:

for (n = 0, i = 100; n! = i; ++ n, - i)
{
   // quoi que ce soit ici ...
}

Cette boucle s’exĂ©cutera 50 fois si ni n ni i ne sont modifiĂ©s dans la boucle:

n commence avec une valeur de 0 et i avec 100, la condition est n! = i (c.-à-d. que n n’est pas égal à i). Puisque n est augmenté de un et que i est diminué de un à chaque itération, la condition de la boucle deviendra fausse après la 50e itération, lorsque n et i sont égaux à 50.

Plage basée sur la boucle

La boucle for a une autre syntaxe, qui est utilisée exclusivement avec des plages:

for (déclaration: plage) instruction;

Ce type de boucle for parcourt tous les Ă©lĂ©ments de la plage, oĂ¹ dĂ©claration dĂ©clare une variable capable de prendre la valeur d’un Ă©lĂ©ment de cette plage. Les plages sont des sĂ©quences d’Ă©lĂ©ments, y compris des tableaux, des conteneurs et tout autre type prenant en charge les fonctions begin et end; La plupart de ces types n’ont pas encore Ă©tĂ© introduits dans ce tutoriel, mais nous connaissons dĂ©jĂ  au moins un type de plage: les chaĂ®nes, qui sont des sĂ©quences de caractères.

Un exemple de boucle for basée sur une plage utilisant des chaînes:

// basé sur la boucle for
#include <iostream>
#include <string>
using namespace std;

int main ()
{
  string str {"Hello!"};
  for (char c: str)
  {
    cout << "[" << c << "]";
  }
  cout << '\ n';
}

Notez que ce qui prĂ©cède les deux points (:) dans la boucle for correspond Ă  la dĂ©claration d’une variable char (les Ă©lĂ©ments d’une chaĂ®ne sont de type char). Nous utilisons ensuite cette variable, c, dans le bloc d’instructions pour reprĂ©senter la valeur de chacun des Ă©lĂ©ments de la plage.

Ă€ lire aussi  C, C ++, C # et Objective-C : quelle diffĂ©rences entre ces langages et comment sont-ils utilisĂ©s ?

Cette boucle est automatique et ne nĂ©cessite la dĂ©claration explicite d’aucune variable de compteur.

Les boucles basĂ©es sur la plage utilisent gĂ©nĂ©ralement aussi la dĂ©duction de type pour le type des Ă©lĂ©ments avec auto. Typiquement, la boucle basĂ©e sur la plage ci-dessus peut Ă©galement Ăªtre Ă©crite comme suit:

for (auto c: str)
  cout << "[" << c << "]";

Ici, le type de c est automatiquement déduit comme le type des éléments dans str.

Instructions de saut

Les instructions de saut permettent de modifier le flux d’un programme en effectuant des sauts vers des emplacements spĂ©cifiques.

L’instruction Break

break laisse une boucle, mĂªme si la condition pour sa fin n’est pas remplie. Il peut Ăªtre utilisĂ© pour terminer une boucle infinie ou pour la forcer Ă  se terminer avant sa fin naturelle. Par exemple, arrĂªtons le compte Ă  rebours avant sa fin naturelle:

// exemple de boucle avec break
#include <iostream>
using namespace std;

int main ()
{
  for (int n = 10; n> 0; n--)
  {
    cout << n << ",";
    si (n == 3)
    {
      cout << "compte à rebours avorté!";
      Pause;
    }
  }
}

L’instruction continue

L’instruction continue force le programme Ă  ignorer le reste de la boucle dans l’itĂ©ration actuelle, comme si la fin du bloc d’instructions avait Ă©tĂ© atteinte, le faisant ainsi sauter au dĂ©but de l’itĂ©ration suivante. Par exemple, passons au numĂ©ro 5 de notre compte Ă  rebours:

// exemple de boucle avec  continue
#include <iostream>
using namespace std;

int main ()
{
  for (int n = 10; n> 0; n--) {
    si (n == 5) continue;
    cout << n << ",";
  }
  cout << "décollage! \ n";
}

L’instruction goto

goto permet de faire un saut absolu Ă  un autre point du programme. Ce saut inconditionnel ignore les niveaux d’imbrication et ne provoque pas de dĂ©roulement automatique de la pile. C’est donc une caractĂ©ristique Ă  utiliser avec prĂ©caution, et de prĂ©fĂ©rence dans le mĂªme bloc d’instructions, en particulier en prĂ©sence de variables locales.

Le point de destination est identifiĂ© par une Ă©tiquette, qui est ensuite utilisĂ©e comme argument pour l’instruction goto. Une Ă©tiquette est composĂ©e d’un identifiant valide suivi de deux points (:).

goto est gĂ©nĂ©ralement considĂ©rĂ© comme une fonctionnalitĂ© de bas niveau, sans cas d’utilisation particulier dans les paradigmes de programmation de haut niveau modernes gĂ©nĂ©ralement utilisĂ©s avec C ++. Mais, Ă  titre d’exemple, voici une version de notre boucle de compte Ă  rebours utilisant goto:

// exemple de boucle goto
#include <iostream>
using namespace std;

int main ()
{
  int n = 10;
mylabel:
  cout << n << ",";
  n--;
  if (n> 0) passez à mylabel;
  cout << "décollage! \ n";
}

Une autre instruction de sélection: switch

La syntaxe de l’instruction switch est un peu particulière. Son but est de rechercher une valeur parmi un certain nombre d’expressions constantes possibles. C’est quelque chose de similaire Ă  la concatĂ©nation d’instructions if-else, mais limitĂ©e aux expressions constantes. Sa syntaxe la plus typique est:

switch (expression)
{
case constant1:
group-of-statements-1;
break;
case constant2:
group-of-statements-2;
break;
.
.
.
default:
default-group-of-statements
}

Cela fonctionne de la manière suivante: switch Ă©value une expression et vĂ©rifie si elle est Ă©quivalente Ă  constant1; si c’est le cas, il exĂ©cute le groupe de dĂ©clarations-1 jusqu’Ă  ce qu’il trouve l’instruction break. Lorsqu’il trouve cette instruction break, le programme saute Ă  la fin de l’instruction switch entière (l’accolade fermante).

Si expression n’Ă©tait pas Ă©gale Ă  constant1, il est ensuite comparĂ© Ă  constant2. S’il est Ă©gal Ă  cela, il exĂ©cute le groupe d’instructions-2 jusqu’Ă  ce qu’une pause soit trouvĂ©e, puis saute Ă  la fin du commutateur.

Enfin, si la valeur de expression ne correspond Ă  aucune des constantes spĂ©cifiĂ©es prĂ©cĂ©demment (il peut y en avoir un nombre quelconque), le programme exĂ©cute les instructions incluses après le libellĂ© par dĂ©faut: label, s’il existe (car il est facultatif).

Les deux fragments de code suivants ont le mĂªme comportement, dĂ©montrant l’Ă©quivalent if-else d’une instruction switch:

exemple de switch équivalence if-else
switch (x) {

case 1:

cout << "x is 1";

break;

case 2:

cout << "x is 2";

break;

default:

cout << "valeur de l'inconnu x";

}
if (x == 1) {

cout << "x is 1";

}

else if (x == 2) {

cout << "x is 2";

}

else {

cout << "valeur de l'inconnu x";

}

L’instruction switch a une syntaxe quelque peu particulière hĂ©ritĂ©e des dĂ©buts des premiers compilateurs C, car elle utilise des Ă©tiquettes au lieu de blocs. Dans l’utilisation la plus typique (indiquĂ©e ci-dessus), cela signifie que des instructions de sĂ©paration sont nĂ©cessaires après chaque groupe d’instructions pour une Ă©tiquette particulière. Si break n’est pas inclus, toutes les instructions suivant le cas (y compris celles sous toute autre Ă©tiquette) sont Ă©galement exĂ©cutĂ©es jusqu’Ă  ce que la fin du bloc commutateur ou une instruction de saut (telle que break) soit atteinte.

Si l’exemple ci-dessus ne comportait pas l’instruction break après le premier groupe pour le cas un, le programme ne sauterait pas automatiquement Ă  la fin du bloc de commutateur après avoir imprimĂ© x est Ă©gal Ă  1, et continuerait plutĂ´t Ă  exĂ©cuter les instructions dans le cas deux (imprimant ainsi x est 2). Il continuerait ensuite Ă  le faire jusqu’Ă  ce qu’une instruction break soit rencontrĂ©e ou jusqu’Ă  la fin du bloc de commutation. Cela Ă©vite de placer les instructions de chaque cas entre accolades {} et peut Ă©galement s’avĂ©rer utile pour exĂ©cuter le mĂªme groupe d’instructions pour diffĂ©rentes valeurs possibles. Par exemple:

switch (x) {
  cas 1:
  cas 2:
  cas 3:
    cout << "x est 1, 2 ou 3";
    break;
  default:
    cout << "x n'est pas 1, 2 ni 3";
  }

Notez que switch est limitĂ© pour comparer l’expression Ă©valuĂ©e Ă  des Ă©tiquettes qui sont des expressions constantes. Il n’est pas possible d’utiliser des variables en tant qu’Ă©tiquettes ou en tant que plages, car elles ne sont pas des expressions constantes C ++ valides.

Pour vĂ©rifier les plages ou les valeurs qui ne sont pas constantes, il est prĂ©fĂ©rable d’utiliser des concatĂ©nations d’instructions if et else if.


Articles similaires

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Bouton retour en haut de la page