Instruction switch (C)

Les instructions switch et case aident à contrôler les opérations conditionnelles et de création de branche complexes. L'instruction switch transfère le contrôle à une instruction dans son corps.

Syntaxe

selection-statement:
  switch ( expression ) statement

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 expression.

Les valeurs de expression et chaque constant-expression doivent avoir un type intégral. Une constant-expression doit avoir une valeur intégrale constante non ambiguë au moment de la compilation.

Le contrôle passe à l’instruction case dont la valeur constant-expression correspond à la valeur de expression. L’instruction switch peut inclure un nombre quelconque d’instances case. Toutefois, deux valeurs constant-expression ne peuvent pas être identiques dans la même instruction switch. L’exécution du corps de l’instruction switch commence à la première instruction dans ou après la labeled-statement correspondante. L’exécution se poursuit jusqu’à la fin du corps, ou jusqu’à ce qu’une instruction break transfère le contrôle hors du corps.

L'utilisation de l'instruction switch ressemble généralement à ceci :

switch ( expression )
{
    // declarations
    // . . .
    case constant_expression:
        // statements executed if the expression equals the
        // value of this constant_expression
        break;
    default:
        // statements executed if expression does not equal
        // any case constant_expression
}

Vous pouvez utiliser l’instruction break pour mettre fin au traitement d’une instruction étiquetée particulière à l’intérieur de l’instruction switch . Elle se branche à la fin de l’instruction switch. À défaut de break, le programme continue jusqu’à l’instruction étiquetée suivante, exécutant les instructions jusqu’à rencontrer un break ou atteindre la fin de l’instruction. Cette continuation peut être souhaitable dans certaines situations.

L’instruction default est exécutée si aucune valeur caseconstant-expression n’est égale à la valeur de expression. S’il n’y a pas d’instruction default et qu’aucune correspondance de case n’est trouvée, aucune des instructions du corps switch n’est exécutée. Il peut y avoir au plus une instruction default. L’instruction default ne dois pas nécessairement venir à la fin. 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.

Le type de switchexpression et caseconstant-expression doit être intégral. La valeur de chaque caseconstant-expression doit être unique dans le corps de l’instruction.

Les étiquettes case et default du corps de l’instruction switch sont significatives uniquement lors du test initial qui détermine où commence l’exécution dans le corps de l’instruction. Les instructions switch peuvent être imbriquées. Toutes les variables statiques sont initialisées avant l'exécution dans les instructions switch.

Notes

Des déclarations peuvent apparaître au début de l'instruction composée formant le corps de switch, mais les initialisations incluses dans les déclarations ne sont pas exécutées. L'instruction switch transfère le contrôle directement à une instruction exécutable dans le corps, en ignorant les lignes qui contiennent des initialisations.

L'exemples suivant illustre des instructions switch :

switch( c )
{
    case 'A':
        capital_a++;
    case 'a':
        letter_a++;
    default :
        total++;
}

Les trois instructions du corps de switch dans cet exemple sont exécutées si c est égal à 'A', car aucune instruction break n’apparaît avant l’étiquette case suivante. Le contrôle d'exécution est transféré à la première instruction (capital_a++;) et continue dans l'ordre à travers le reste du corps. Si c est égal à 'a', letter_a et total sont incrémentés. Seul total est incrémenté quand c n’est pas égal à 'A' ou 'a'.

switch( i )
{
    case -1:
        n++;
        break;
    case 0 :
        z++;
        break;
    case 1 :
        p++;
        break;
}

Dans cet exemple, une instruction break suit chaque instruction du corps de switch. L’instruction break force une sortie du corps de l’instruction après l’exécution d’une instruction. Si i est égal à -1, seul n est incrémenté. Le break suivant l’instruction n++; a pour effet de passer le contrôle d’exécution hors du corps de l’instruction, et d’ignorer les instructions restantes. De même, si i est égal à 0, seul z est incrémenté ; si i est égal à 1, seul p est incrémenté. L’instruction break finale n’est pas strictement nécessaire, car le contrôle passe hors du corps à la fin de l’instruction composée. Elle est incluse pour la cohérence.

Une même instruction peut porter plusieurs étiquettes case, comme illustré dans l’exemple suivant :

switch( c )
{
    case 'a' :
    case 'b' :
    case 'c' :
    case 'd' :
    case 'e' :
    case 'f' :  convert_hex(c);
}

Dans cet exemple, si constant-expression est égale à une lettre entre 'a' et 'f', la fonction convert_hex est appelée.

Spécifique à Microsoft

Microsoft C ne limite pas le nombre de valeurs case dans une instruction switch. Le nombre est limité uniquement par la mémoire disponible. C ANSI requiert qu’au moins 257 étiquettes case soient autorisées dans une instruction switch.

Le paramétrage default pour Microsoft C, est que les extensions Microsoft sont activées. Utilisez l’option du compilateur /Za pour désactiver ces extensions.

Voir aussi

Instruction switch (C++)