C++
Contrôle de flux

Remarques

Cas

Introduit une étiquette de cas d'une instruction switch. L'opérande doit être une expression constante et correspondre à la condition du commutateur dans le type. Lorsque l'instruction switch est exécutée, elle saute à l'étiquette de cas avec un opérande égal à la condition, le cas échéant.

char c = getchar();
bool confirmed;
switch (c) {
  case 'y':
    confirmed = true;
    break;
  case 'n':
    confirmed = false;
    break;
  default:
    std::cout << "invalid response!\n";
    abort();
}

commutateur

Selon le standard C ++,

L'instruction switch entraîne le transfert du contrôle sur l'une des instructions en fonction de la valeur d'une condition.

Le mot clé switch est suivi d'une condition entre parenthèses et d'un bloc, pouvant contenir des étiquettes de case et une étiquette default facultative. Lorsque l'instruction switch est exécutée, le contrôle est transféré vers une étiquette de case avec une valeur correspondant à celle de la condition, le cas échéant, ou à l'étiquette default , le cas échéant.

La condition doit être une expression ou une déclaration, de type entier ou énumération, ou un type de classe avec une fonction de conversion en type entier ou énumération.

char c = getchar();
bool confirmed;
switch (c) {
  case 'y':
    confirmed = true;
    break;
  case 'n':
    confirmed = false;
    break;
  default:
    std::cout << "invalid response!\n";
    abort();
}

capture

Le mot clé catch introduit un gestionnaire d'exceptions, c'est-à-dire un bloc dans lequel le contrôle sera transféré lorsqu'une exception de type compatible est levée. Le mot-clé catch est suivi d'une déclaration d'exception entre parenthèses, dont la forme est similaire à celle d'une déclaration de paramètre de fonction: le nom du paramètre peut être omis et les points de suspension ... sont autorisés, ce qui correspond à tout type. Le gestionnaire d'exceptions ne traitera l'exception que si sa déclaration est compatible avec le type de l'exception. Pour plus de détails, voir les exceptions en attente .

try {
    std::vector<int> v(N);
    // do something
} catch (const std::bad_alloc&) {
    std::cout << "failed to allocate memory for vector!" << std::endl;
} catch (const std::runtime_error& e) {
    std::cout << "runtime error: " << e.what() << std::endl;
} catch (...) {
    std::cout << "unexpected exception!" << std::endl;
    throw;
}

défaut

Dans une instruction switch, introduit une étiquette sur laquelle on sautera si la valeur de la condition n'est pas égale à l'une des valeurs des étiquettes de cas.

char c = getchar();
bool confirmed;
switch (c) {
  case 'y':
    confirmed = true;
    break;
  case 'n':
    confirmed = false;
    break;
  default:
    std::cout << "invalid response!\n";
    abort();
}

class Base {
    // ...
    // we want to be able to delete derived classes through Base*,
    // but have the usual behaviour for Base's destructor.
    virtual ~Base() = default;
};

si

Introduit une instruction if. Le mot if clé if doit être suivi d'une condition entre parenthèses, qui peut être une expression ou une déclaration. Si la condition est vraie, le sous-élément après la condition sera exécuté.

int x;
std::cout << "Please enter a positive number." << std::endl;
std::cin >> x;
if (x <= 0) {
    std::cout << "You didn't enter a positive number!" << std::endl;
    abort();
}

autre

Le premier sous-composant d'une instruction if peut être suivi du mot-clé else . Le sous-composant après le mot-clé else sera exécuté lorsque la condition est Falsey (c'est-à-dire lorsque le premier sous-composant n'est pas exécuté).

int x;
std::cin >> x;
if (x%2 == 0) {
    std::cout << "The number is even\n";
} else {
    std::cout << "The number is odd\n";
}

aller à

Passe à une instruction étiquetée, qui doit être située dans la fonction en cours.

bool f(int arg) {
    bool result = false;
    hWidget widget = get_widget(arg);
    if (!g()) {
        // we can't continue, but must do cleanup still
        goto end;
    }
    // ...
    result = true;
  end:
    release_widget(widget);
    return result;
}

revenir

Renvoie le contrôle d'une fonction à son appelant.

Si return a un opérande, l'opérande est converti en type de retour de la fonction et la valeur convertie est renvoyée à l'appelant.

int f() {
    return 42;
}
int x = f(); // x is 42
int g() {
    return 3.14;
}
int y = g(); // y is 3

Si return n'a pas d'opérande, la fonction doit avoir un type de retour void . En tant que cas particulier, une fonction de retour void peut également renvoyer une expression si l'expression est de type void .

void f(int x) {
    if (x < 0) return;
    std::cout << sqrt(x);
}
int g() { return 42; }
void h() {
    return f(); // calls f, then returns
    return g(); // ill-formed
}

Lorsque main retourne, std::exit est implicitement appelé avec la valeur de retour et la valeur est donc renvoyée dans l'environnement d'exécution. (Cependant, le retour de main détruit les variables locales automatiques, alors que l'appel de std::exit ne le fait pas directement.)

int main(int argc, char** argv) {
    if (argc < 2) {
        std::cout << "Missing argument\n";
        return EXIT_FAILURE; // equivalent to: exit(EXIT_FAILURE);
    }
}

jeter

1. Lorsque throw se produit dans une expression avec un opérande, son effet est de lancer une exception , qui est une copie de l'opérande.

   void print_asterisks(int count) {
       if (count < 0) {
           throw std::invalid_argument("count cannot be negative!");
       }
       while (count--) { putchar('*'); }
   }
   

2. Lorsque throw se produit dans une expression sans opérande, son effet est de renvoyer l'exception en cours . S'il n'y a pas d'exception actuelle, std::terminate est appelée.

   try {
       // something risky
   } catch (const std::bad_alloc&) {
       std::cerr << "out of memory" << std::endl;
   } catch (...) {
       std::cerr << "unexpected exception" << std::endl;
       // hope the caller knows how to handle this exception
       throw;
   }
   

3. Lorsque throw se produit dans un déclarateur de fonction, il introduit une spécification d'exception dynamique, qui répertorie les types d'exceptions que la fonction est autorisée à propager.

   // this function might propagate a std::runtime_error,
   // but not, say, a std::logic_error
   void risky() throw(std::runtime_error);
   // this function can't propagate any exceptions
   void safe() throw();
   

   Les spécifications d'exception dynamiques sont obsolètes à partir de C ++ 11.

Notez que les deux premières utilisations de throw listées ci-dessus constituent des expressions plutôt que des déclarations. (Le type d'une expression est void .) Cela permet de les imbriquer dans des expressions, comme ceci:

unsigned int predecessor(unsigned int x) {
    return (x > 0) ? (x - 1) : (throw std::invalid_argument("0 has no predecessor"));
}

essayer

Le mot-clé try est suivi d'un bloc ou d'une liste d'initialisation du constructeur, puis d'un bloc (voir ici ). Le bloc try est suivi d'un ou plusieurs blocs catch . Si une exception se propage hors du bloc try, chacun des blocs catch correspondants après le bloc try a la possibilité de gérer l'exception, si les types correspondent.

std::vector<int> v(N);     // if an exception is thrown here,
                           // it will not be caught by the following catch block
try {
    std::vector<int> v(N); // if an exception is thrown here,
                           // it will be caught by the following catch block
    // do something with v
} catch (const std::bad_alloc&) {
    // handle bad_alloc exceptions from the try block
}    

Structures conditionnelles: si, si..se

si et sinon:

il permet de vérifier si l'expression donnée renvoie true ou false et agit comme tel:

if (condition) statement

la condition peut être toute expression C ++ valide qui renvoie quelque chose qui soit vérifié par rapport à la vérité / au mensonge, par exemple:

if (true) { /* code here */ }  // evaluate that true is true and execute the code in the brackets
if (false) { /* code here */ } // always skip the code since false is always false

la condition peut être n'importe quoi, une fonction, une variable ou une comparaison par exemple

if(istrue()) { } // evaluate the function, if it returns true, the if will execute the code
if(isTrue(var)) { } //evalute the return of the function after passing the argument var
if(a == b) { } // this will evaluate the return of the experssion (a==b) which will be true if equal and false if unequal
if(a) { } //if a is a boolean type, it will evaluate for its value, if it's an integer, any non zero value will be true, 

Si nous voulons vérifier plusieurs expressions, nous pouvons le faire de deux manières:

en utilisant des opérateurs binaires :

if (a && b) { } // will be true only if both a and b are true (binary operators are outside the scope here
if (a || b ) { } //true if a or b is true 

en utilisant if / ifelse / else :

pour un simple commutateur si ou sinon

if (a== "test") {
    //will execute if a is a string "test" 
} else {
    // only if the first failed, will execute 
}

pour des choix multiples:

if (a=='a') { 
// if a is a char valued 'a'  
} else if (a=='b') {
// if a is a char valued 'b' 
} else if (a=='c') {
// if a is a char valued 'c'
} else { 
//if a is none of the above
}

Cependant, il faut noter que vous devez utiliser ' switch ' à la place si votre code vérifie la valeur de la même variable

Instructions de saut: pause, continuer, aller, sortir.

L'instruction de pause:

En utilisant break, nous pouvons laisser une boucle même si la condition de sa fin n'est pas remplie. Il peut être utilisé pour terminer une boucle infinie ou pour le forcer à se terminer avant sa fin naturelle

La syntaxe est

break;

Exemple: nous utilisons souvent break dans l' switch cas, par exemple une fois par cas i commutateur est satisfait alors le bloc de code de cette condition est exécutée.

switch(conditon){
case 1: block1;
case 2: block2;
case 3: block3;
default: blockdefault;
} 

dans ce cas, si le cas 1 est satisfait, alors le bloc 1 est exécuté, ce que nous voulons vraiment, c'est que le bloc1 soit traité, mais les blocs restants, block2, block3 et blockdefault sont traités même si seul le cas 1 est satisfait .Pour éviter cela, nous utilisons break à la fin de chaque bloc comme:

switch(condition){
case 1: block1;
        break;
case 2: block2;
        break;
case 3: block3;
        break;
default: blockdefault;
        break;
}

Ainsi, un seul bloc est traité et le contrôle quitte la boucle de commutation.

break peut également être utilisé dans d'autres boucles conditionnelles et non conditionnelles comme if , while , for etc.

Exemple:

if(condition1){
   ....
   if(condition2){
    .......
    break;
    }
 ...
}

L'instruction continue:

L'instruction continue oblige le programme à ignorer le reste de la boucle dans l'itération actuelle, comme si la fin du bloc d'instruction aurait été atteinte, ce qui l'amènerait à passer à l'itération suivante.

La syntaxe est

continue;

Exemple considérer les points suivants:

for(int i=0;i<10;i++){
if(i%2==0)
continue;
cout<<"\n @"<<i;
}

qui produit la sortie:

 @1
 @3
 @5
 @7
 @9

i ce code à chaque fois que la condition i%2==0 est satisfaite continue est traitée, ce qui provoque le compilateur pour sauter tout le code restant (impression @ i) et l' état incrément / décrément de la boucle est exécuté.

L'instruction goto:

Cela permet de sauter à un autre point du programme. Vous devez utiliser cette fonctionnalité avec précaution car son exécution ignore tout type de limitation d'imbrication. Le point de destination est identifié par une étiquette, qui est ensuite utilisée comme argument pour l'instruction goto. Une étiquette est faite d'un identifiant valide suivi d'un deux-points (:)

La syntaxe est

goto label;
..
.
label: statement;

Remarque: L' utilisation de l'instruction goto est fortement déconseillée car elle rend difficile le suivi du flux de contrôle d'un programme, rendant le programme difficile à comprendre et à modifier.

Exemple :

int num = 1;
STEP:
do{
 
    if( num%2==0 )
    {
        num = num + 1;
        goto STEP;
     }

   cout << "value of num : " << num << endl;
   num = num + 1;
 }while( num < 10 );

sortie:

value of num : 1
value of num : 3
value of num : 5
value of num : 7
value of num : 9

chaque fois que la condition num%2==0 est satisfaite, le goto envoie le contrôle d'exécution au début de la boucle do-while while.

La fonction de sortie:

exit est une fonction définie dans cstdlib . Le but de exit est de terminer le programme en cours avec un code de sortie spécifique. Son prototype est:

void exit (int exit code);

cstdlib définit les codes de sortie standard EXIT_SUCCESS et EXIT_FAILURE .