Sauter d'un cas au cas par défaut dans l'instruction switch

switch(ch){
          case 'a':
                 //do something, condition does not match so go to default case
                 //don't break in here, and don't allow fall through to other cases.
          case 'b':
                 //..
          case 'c':
                 //..
          case '_':
                 //...
          default:
                 //
                 break;
}

Dans une instruction switch comme ci-dessus, un-je entrer dans de cas "a", je me casse seulement si la condition à l'intérieur, il se produit, sinon j'ai envie de sauter au cas par défaut. Est-il un autre moyen de faire ceci plutôt que des étiquettes ou des gotos?

source d'informationauteur thetux4

break c switch-statement

goto Pour La Victoire

switch (ch) {
    case 'a':
        if (1) goto LINE96532;
        break;
    case 'b':
        if (1) goto LINE96532;
        break;
LINE96532:
    default:
        //
        break;
}

Simplement réorganiser le cas, de sorte que cette affaire est la dernière:

switch(ch){
          case 'b':
                 //..
          case 'c':
                 //..
          case '_':
                 //...
          case 'a':
                 //do something, condition does not match so go to default case
                 if (condition)
                     break;
                 //don't break in here, and don't allow fall through to other cases.
          default:
                 //
                 break;
}

Si la condition ne dépend pas de cas, pourquoi le mettre à l'intérieur?

if (!condition){
  //do default
}else{
  switch(ch){
    case 'a':
      //do a
      break;
    ...
  }
}

5

Restructurer le code:
```
int test_char(char ch)
{
  switch(ch) {
    case 'a': if (condition) return 0; break;
    case 'b': //...
    default: return -1;
  }

  return 1;
}

... 
//defaults processing switch
switch(test_char(ch)) {
  case 0: break; //condition met
  case 1: //default processing
  default: //case not handled by test_char
}
```
Cela ajoute aussi l'avantage d'être souple pour tester plusieurs classes de traitement par défaut. Disons que vous avez un groupe de caractères [c, d, e, f], qui partagent certaines de logique. Il suffit de le retourner 2 à partir de test_char() pour ces cas (éventuellement après quelques conditions a été testé), et ajoutez un cas 2: gestionnaire pour le traitement par défaut de l'instruction switch.
1

Je ne suis pas sûr si th est la meilleure réponse, mais ici, il va:

Si vous ne voulez absolument pas utiliser des étiquettes, et vous voulez garder le cas dans leur ordre actuel, alors vous pouvez continuer, après le cas " a " et ensuite vérifier afin de voir si(ch != 'a') au début de chaque cas, seule l'exécution de l'instruction si la condition est vraie:
```
switch(ch){
    case 'a':
        //do something
    case 'b':
    if(ch != 'a') {
        //do something
    }
    //repeat for each subsequent case
    default:
        //do something
    break;
}
```
Ce n'est probablement pas le moyen le plus efficace pour résoudre votre problème, mais il devrait accomplir ce que vous voulez.

Si vous devez avoir les instructions de commutation d'abord parce que l'état vous êtes à la vérification dépend de la cause (ou le cas doit être évalué en premier avant de vous pouvez vérifier l'état), il suffit de définir un indicateur à l'intérieur de votre switch cas, et si ce drapeau est mis, puis faire un mode de fonctionnement par défaut. Par exemple:

int default_true = 0;
switch (case_value)
{
    case 'a': /* if the condition is true, set the default_true flag */

    case 'b': /* if the condition is true, set the default_true flag */

    //...

    default: default_flag = 1; //set the default_true flag to true
}

if (default_flag)
{
    //place your "default" code here rather than inside the switch statement
    //this prevents code reduplication
}

Voici ce que j'ai fait:

char ucResult = 1;
switch(ch){
      case 'a':
          if(ucResult){
             //do something
             if(error) ucResult = 0;
          }
      case 'b':
          if(ucResult){
             //do something
             if(error) ucResult = 0;
          }
      case 'c':
          if(ucResult){
             //do something
             if(error) ucResult = 0;
          }
      case '_':
          if(ucResult){
             //do something
             if(error) ucResult = 0;
          }
      default:
             //
             break;
}

Avec cette structure, vous pouvez basculer en cas de défaut de tout cas précédents. Pratique pour casser extérieur des boucles de trop.

J'espère que ma solution répond à votre question. Il suffit de laisser le cas, suivez à travers tout le chemin (à partir de l'appariement des cas) mais l'utilisation d'une condition de désactiver les cas ultérieurs de l'exécution.

typedef enum boolean
{
    FALSE = 0, TRUE = 1
} bool;

void pstuff(char input)
{
    bool _skip = FALSE; 
    switch(input)
    {
        case 'a':
            printf("Case a.");
            _skip = TRUE; 
        case 'b': 
            if(!_skip)
            {
                printf("Case b.");
                _skip = TRUE;
            }
        case 'c':       
            if(!_skip)
            {
                printf("Case c.");
                _skip = TRUE; 
            }
        //...
        default: 
            printf("Done!\n"); //Always gets printed.

    }   
}

-2

saut à défaut

utiliser un caisson vide label par défaut ci-dessus ( avec un nom évident )

Utilisation goto case "case-labelname" pour sauter, puis chute jusqu'à défaut.

exemple

    switch (VAR)
{
    case "a":
        //dO STUFF !
    if(COND)
            goto case "DFLT";
        //dO STUFF !
        break;
    case "B":
        //dO STUFF !
        break;
    case "C":
        //dO STUFF !
    IF(COND)
            goto case "DFLT";
        break;
    case "DFLT":
    default:

       //dO DEFAULT
        break;
}

Vous devez vous connecter pour publier un commentaire.