commutateur double ou simple

Question

Eh bien, il est peut-être une question stupide, mais je suis incapable de trouver une réponse:

L'affaire est simple, j'ai une fonction avec un nombre entier dans l'entrée et deux variables à attribuer en fonction de cette. Le problème est que la valeur assignée aux variables est commune à certains cas, mais ces cas ne sont pas les mêmes pour les deux variables. (Si ce n'est pas assez clair, voir l'exemple). Je me demandais quelle était la meilleure pratique pour un tel cas. Est-il quelque chose comme:

function test(a){ 
    var x,y; 
    switch (a){ 
     case 0: 
     case 1: 
     case 7: 
      y=...; 
      break; 
     case 2: 
     case 6: 
      y=...; 
      break; 
     case 3: 
     case 4: 
     case 5: 
      y=...; 
    } 
    switch(a){ 
     case 5: 
     case 6: 
     case 7: 
      x=...; 
      break; 
     case 0: 
     case 4: 
      x=...; 
      break; 
     case 1: 
     case 2: 
     case 3: 
      x=...; 
    } 
    ... 
} 

ou

function test(a){ 
    var x,y; 
    switch (a){ 
     case 0: 
      x=...; 
      y=...; 
      break;    
     case 1: 
      x=...; 
      y=...; 
      break; 
     case 2: 
      x=...; 
      y=...; 
      break; 
     case 3: 
      x=...; 
      y=...; 
      break; 
     case 4: 
      x=...; 
      y=...; 
      break; 
     case 5: 
      x=...; 
      y=...; 
      break; 
     case 6: 
      x=...; 
      y=...; 
      break; 
     case 7: 
      x=...; 
      y=...; 
    } 
    ... 
} 

Ou utiliser un mélange des deux avec la valeur attribuée à x dans chaque cas et de faire des groupes pour la valeur de y? Notez qu'il peut y avoir plus de 8 valeur, c'est juste pour l'exemple. Merci d'avance.

Answer 1

S'il n'y a pas de chevauchement réel entre les différents cas dans les instructions switch, il vaut probablement mieux les séparer.

S'il y avait une majorité de points communs entre les actions, vous pourriez les combiner avec certains cas spéciaux au sein des blocs individuels case mais vous semblez indiquer que ce n'est pas le cas ici.

Cependant, si ce n'est pas seulement un exemple simple d'un beaucoup cas plus complexe, vous pouvez obtenir une solution plus compacte avec quelque chose comme:

//      index: 0 1 2 3 4 5 6 7 8 9 10 11 12 
static const int lookupX[] = { 2, 7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9}; 
static const int lookupY[] = { 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9}; 
if ((a >=0) && (a < sizeof(lookupX)/sizeof(*lookupX))) 
    x = lookupX[a]; 
if ((a >=0) && (a < sizeof(lookupY)/sizeof(*lookupY))) 
    y = lookupY[a]; 

Cela vous permettra de garder les valeurs dans une section "configuration" beaucoup plus petite afin que vous puissiez facilement voir l'intention. La vérification de la gamme et la recherche deviennent alors très simples.

Ce code est adapté à C - Je ne suis pas sûr de la langue que vous utilisez (en raison de l'instruction var) mais il ne fait que la recherche si l'index est valide. Vous devrez traduire ce bit dans la langue de votre choix.