Discussion :

[dudu_man]

Salut a tous et a toutes,
Une petite question met venue à l'esprit alors que je faisait un générateur aléatoire de labyrinthe en C. Quelqu'un sait-il comment faire ou est-il possible de faire un switch dont la sélection de l'action a réaliser correspond a un intervalle de valeur? Moi même j'ai un peu de mal avec ma question donc voila un exemple:


la version normal:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
switch(choix)
    {
        case 0: --action 1-- break;
        case 1: --action 1-- break;
        case 2: --action 2-- break;
        case 3: --action 3-- break;
 
    }

la version que je voudrais réaliser:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
switch(choix)
    {
        case  0<choix<10:     --action 1--; break;
        case 10<choix<20:     --action 1--; break;
        case 20<choix<30:     --action 2--; break;
        case 30<choix<40:     --action 3--; break;
 
    }

merci pour vos réponses.

[gangsoleil]

A ma connaissance, il n'est pas possible de specifier des intervalles. Mais tu peux faire comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
switch (choix)
{
  case 1 : 
  case 2 : 
  case 3 : 
  case 4 :  /* code pour 1, 2, 3 ou 4 */  break ;
 
  case 5 : 
  case 6 : 
  case 7 :  /* code de 5 a 7 */ break
 
  default : /* other */ break;
}

[foetus]

switch(choix)
{
case 0<choix<10: --action 1--; break;
case 10<choix<20: --action 1--; break;
case 20<choix<30: --action 2--; break;
case 30<choix<40: --action 3--; break;

}

On peut le faire en C , en sachant que le switch n'accepte que des entiers

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
    if ((choix >= 0) && (choix <= 9)) {
//      action 1
    } else if ((choix >= 10) && (choix <= 19)) {
//      action 1
    } else if ((choix >= 20) && (choix <= 29)) {
//      action 2
    } else if ((choix >= 30) && (choix <= 39)) {
//      action 3
    }

Et si on combine 2 intervalles

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
    if (((choix >= 0) && (choix <= 9)) || ((choix >= 20) && (choix <= 29))) {
//      action 1
    } else if ((choix >= 10) && (choix <= 19)) {
//      action 2
    } else if ((choix >= 30) && (choix <= 39)) {
//      action 3
    }

Édit: gangsoleil a raison case est un mot clef . Et pour un coup en français

[gangsoleil]

Attention, ce n'est pas if ((case < ..., mais if ((choix < ...

if (( case va provoquer une erreur de syntaxe.

[Bktero]

A proprement parlé, switch n'est pas une fonction mais un opérateur. Et non il ne permet pas de faire des sélections sur des plages.

Tu as la solution de gangsoleil, à mon avis peu lisible et maintenable. Tu as la solution de foetus, qui peut-être améliorée avec une fonction ou une macro isInRange(min, max).

[Metalman]

Idée "stupide", mais dans le même genre que foetus : faire une enum, et faire un switch/case sur l'énumération !

Si l'énumération "inversée" existait ce serait fabuleux !... mais en C ça serait ardu de déclarer des ensembles de valeurs !

[foetus]

Idée "stupide", mais dans le même genre que foetus : faire une enum, et faire un switch/case sur l'énumération !

Si l'énumération "inversée" existait ce serait fabuleux !... mais en C ça serait ardu de déclarer des ensembles de valeurs !

Si tu es [très] joueur tu peux faire un espèce de "hash" pour les intervalles

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
    int hash = generate_hash(choice);
 
    switch (hash) {
    case HASH_ACTION_1: /* action1 */ break;
    case HASH_ACTION_2: /* action2 */ break;
    case HASH_ACTION_3: /* action3 */ break;
    default: /* other */ break;
    }

[Metalman]

Exact... c'est ce que j'imaginais pour la solution "pratique" ! :p
Du coup une banale enum sur 0, 1, 2, 3, 4 + le hash qui divise par 10 et renvoie l'enum...
Et on a la solution. (l'enum servant "uniquement" à symboliser/abstraire les résultats "bruts")

Et ça s'approche de la fonction IsInRange() dans l'idée !

[Bktero]

Pourquoi faire simple quand on peut faire compliqué, hein ?

[Metalman]

En soit, le coup du hash serait le plus "lisible" et le plus simple à maintenir :

- Une fonction génère un "truc" qui désigne un intervalle de valeurs [le "truc" c'est l'enum du coup]
- Le switch qui décrit clairement ce que l'on fait pour chaque intervalle

Et seule la fonction de hash évoluera si d'autres cas apparaissent (l'ajout de case n'est pas monstrueusement complexe à faire évoluer, pareil pour l'enum).


C'est simple, lisible, et la fonction de hash peut être exportée dans un autre fichier pour ne pas densifier le code initial.

[Bktero]

C'est vrai si tu as besoin de faire le même test de plage ailleurs, je te l'accorde.

Dans le cas contraire, l'intérêt semble limité : fonction faisant des if / else pour renvoyer un type énuméré à maintenir puis switch / case sur à faire sur toutes les valeurs de l'énumération d'un côté ; uniquement les if / else de l'autre.

[dudu_man]

Merci à tous pour vos réponse. Je vais donc mettre un peu d'ordre. Apres avoir posé cette question j'ai continué a faire des recherche, j'ai eu la réponse et vous me l'avez confirmé. il est impossible de faire un switch avec une plage de nombre. Par contre les deux solution proposé ont, à mon avis du bon et du moins bon. Pour les if; else if ... faut le dire c'est pas super lisible mais dans un petit programme c'est le plus court je pense. Le hash, la première solution à laquelle j'avais pensé et beaucoup plus lisible mais plus longue à mettre en place je pense que dans un gros programme j'opterais pour cette alternative, ça fait plus propre

[johnlobs]

Bonjour,
je pense que l’idéal serait de faire du très simple: si tu as des intervalles regulier comme dans ta question
tu fais une division entiere par le maximum du premier intervalle c a d:
10 dans ton cas:
5 etant compris entre 0 et 10 te renverra 0
12 etant compris entre 10 et 20 te renverra 1
25 etant compris entre 20 et 30 te renverra 2
ca reviendrait à faire un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
switch (choix/10) 
 {
        case 0: --action 1-- break;
        case 1: --action 1-- break;
        case 2: --action 2-- break;
        case 3: --action 3-- break;
 
    }

sinon tu génère grace a une fonction des éléments sur lesquels tu switch...
bon courage

[frouppy]

Je débute vraiment en C++, et j'ai une question sans doute bête : POURQUOI le C++ ne permet-il pas les intervalles avec Switch, ça me semblerait tellement pratique.

[Sve@r]

Bonjour

Je débute vraiment en C++

C'est super car ici c'est un forum de C !!! Donc non seulement tu viens déterrer un topic de 4 ans mais non pas pour y répondre mais pour poser ta bête question et en plus en te trompant au final de rubrique. T'as pas l'impression d'être une grosse tanche le formateur ?

POURQUOI le C++ ne permet-il pas les intervalles avec Switch,

Parce que tu ne sais pas ce qu'il se passe derrière. Le switch(expression) évalue l'expression qui doit correspndre à une valeur puis va se brancher sur les étiquettes qui sont en fait des "labels" de goto. Donc derrière le compilateur transforme ça en goto et ces labels doivent être figés et connus lors de la compilation.

ça me semblerait tellement pratique.

Oh et le monde serait tellement plus beau. Ben tu fais sans. Ou alors tu choisis un langage plus adapté à tes besoins. Parce que tu ne peux pas avoir à la fois un langage proche de la machine et à la fois proche des besoins expressifs du développeur.

[foetus]

Le switch(expression) évalue l'expression qui doit correspondre à une valeur puis va se brancher sur les étiquettes qui sont en fait des "labels" de goto. Donc derrière le compilateur transforme ça en goto et ces labels doivent être figés et connus lors de la compilation

Cela s'appelle des branch table ou jump table (<- lien wiki en anglais)
Et c'est d'ailleurs pour cela qu'un switch est plus performant/ efficace qu'une série de si

Ensuite pour le pourquoi , je me dis qu'en 2018, les compilateurs ne doivent plus utiliser de simples tableaux - pour des cas où l'intervalle est très grand.
Et il y a aussi la gestion des intervalles qui se chevauchent : est-ce que la détection est simple ? est-ce que la prise de décission est simple ?

Et au passage (si cela n'a pas été dit ) gcc propose/ proposait une extension pour avoir des intervalles Case Ranges (<- lien en anglais)