switch instruction (C++)

  • Article

Autorise la sélection parmi plusieurs sections de code, selon la valeur d'une expression intégrale.

Syntaxe

selection-statement:
  switch(init-statementoptC++17condition)statement

init-statement:
  expression-statement
  simple-declaration

condition:
  expression
  attribute-specifier-seqopt decl-specifier-seq declarator brace-or-equal-initializer

labeled-statement:
  case constant-expression : statement
  default : statement

Notes

Une instruction switch entraîne le transfert du contrôle à une labeled-statement dans son corps d’instruction, en fonction de la valeur de condition.

Le condition doit avoir un type intégral, ou être un type de classe qui a une conversion non ambiguë en type intégral. La promotion intégrale a lieu comme décrit dans les conversions Standard.

Le corps de l’instruction switch se compose d’une série d’étiquettes case et d’une optétiquette ionale default . Il labeled-statement s’agit de l’une de ces étiquettes et des instructions qui suivent. Les instructions étiquetées ne sont pas des exigences syntaxiques, mais l’instruction switch est sans signification sans eux. Aucune valeur constant-expression dans les case instructions ne peut être évaluée à la même valeur. L’étiquette default ne peut apparaître qu’une seule fois. L’instruction default est souvent placée à la fin, mais elle peut apparaître n’importe où dans le corps de l’instruction switch . Une étiquette case ou default ne peut apparaître qu’à l’intérieur d’une instruction switch.

L’étiquette constant-expression de chaque case étiquette est convertie en valeur constante qui est le même type que condition. Ensuite, elle est comparée à condition l’égalité. Le contrôle passe à la première instruction après la caseconstant-expression valeur qui correspond à la valeur de condition. Le comportement résultant est indiqué dans le tableau suivant.

switch comportement d’instruction

Condition Action
La valeur convertie correspond à celle de l'expression de contrôle promue. Le contrôle est transféré à l'instruction qui suit cette étiquette.
Aucune des constantes ne correspond aux constantes dans les case étiquettes ; une default étiquette est présente. Le contrôle est transféré vers l’étiquette default .
Aucune des constantes ne correspond aux constantes dans les case étiquettes ; aucune étiquette n’est default présente. Le contrôle est transféré à l’instruction après l’instruction switch .

Si une expression correspondante est trouvée, l’exécution peut continuer via des étiquettes ou default ultérieurescase. L’instruction break est utilisée pour arrêter l’exécution et transférer le contrôle vers l’instruction après l’instruction switch . break Sans instruction, chaque instruction de l’étiquette correspondante case à la fin du switch, y compris le default, est exécutée. Par exemple :

// switch_statement1.cpp
#include <stdio.h>

int main() {
   const char *buffer = "Any character stream";
   int uppercase_A, lowercase_a, other;
   char c;
   uppercase_A = lowercase_a = other = 0;

   while ( c = *buffer++ )   // Walks buffer until NULL
   {
      switch ( c )
      {
         case 'A':
            uppercase_A++;
            break;
         case 'a':
            lowercase_a++;
            break;
         default:
            other++;
      }
   }
   printf_s( "\nUppercase A: %d\nLowercase a: %d\nTotal: %d\n",
      uppercase_A, lowercase_a, (uppercase_A + lowercase_a + other) );
}

Dans l’exemple ci-dessus, uppercase_A est incrémenté s’il c s’agit d’un hautcase'A'. L’instruction break après uppercase_A++ l’exécution du corps de l’instruction et du switch contrôle passe à la while boucle. Sans l’instruction, l’exécution break « passe » à l’instruction étiquetée suivante, de sorte qu’elle lowercase_a soit other également incrémentée. Un objectif similaire est servi par l’instruction break pour case 'a'. Si c elle est inférieurecase'a', lowercase_a est incrémentée et l’instruction break met fin au corps de l’instruction switch . Si c ce n’est pas un 'a' ou 'A', l’instruction default est exécutée.

Visual Studio 2017 et versions ultérieures (disponible en /std:c++17 mode et versions ultérieures) : l’attribut [[fallthrough]] est spécifié dans la norme C++17. Vous pouvez l’utiliser dans une switch instruction. Il s’agit d’un indicateur pour le compilateur, ou toute personne qui lit le code, ce comportement de basculement est intentionnel. Actuellement, le compilateur Microsoft C++ n’avertit pas le comportement de secours. Cet attribut n’a donc aucun effet sur le comportement du compilateur. Dans l’exemple, l’attribut est appliqué à une instruction vide dans l’instruction étiquetée non déterminée. En d’autres termes, le point-virgule est nécessaire.

int main()
{
    int n = 5;
    switch (n)
    {

    case 1:
        a();
        break;
    case 2:
        b();
        d();
        [[fallthrough]]; // I meant to do this!
    case 3:
        c();
        break;
    default:
        d();
        break;
    }

    return 0;
}

Visual Studio 2017 version 15.3 et ultérieure (disponible en /std:c++17 mode et versions ultérieures) : une switch instruction peut avoir une init-statement clause, qui se termine par un point-virgule. Il introduit et initialise une variable dont l’étendue est limitée au bloc de l’instruction switch :

    switch (Gadget gadget(args); auto s = gadget.get_status())
    {
    case status::good:
        gadget.zip();
        break;
    case status::bad:
        throw BadGadget();
    };

Un bloc interne d’une switch instruction peut contenir des définitions avec des initialiseurs tant qu’ils sont accessibles, autrement dit, pas ignorés par tous les chemins d’exécution possibles. Les noms présentés à l'aide de ces déclarations ont une portée locale. Par exemple :

// switch_statement2.cpp
// C2360 expected
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
    switch( tolower( *argv[1] ) )
    {
        // Error. Unreachable declaration.
        char szChEntered[] = "Character entered was: ";

    case 'a' :
        {
        // Declaration of szChEntered OK. Local scope.
        char szChEntered[] = "Character entered was: ";
        cout << szChEntered << "a\n";
        }
        break;

    case 'b' :
        // Value of szChEntered undefined.
        cout << szChEntered << "b\n";
        break;

    default:
        // Value of szChEntered undefined.
        cout << szChEntered << "neither a nor b\n";
        break;
    }
}

Une switch instruction peut être imbriquée. Lorsqu’elles sont imbriquées, les case étiquettes ou default les associent à l’instruction la plus switch proche qui les entoure.

Comportement spécifique à Microsoft

Microsoft C++ ne limite pas le nombre de case valeurs dans une switch instruction. Le nombre est limité uniquement par la mémoire disponible.

Voir aussi

Instructions de sélection
Mots clés