Discussion :

[NESTLE]

Bonjour,
Peut-on faire un switch avec 2 conditions ?
Et comment on déclare les Case ?
Merci de votre aide
A+

[magicpm7]

Bonjour,

peux-tu être plus précis s'il te plait ? Qu'est-ce que tu entends par "deux conditions" ? Merci.

[poukill]

Bonjour,
Peut-on faire un switch avec 2 conditions ?
Et comment on déclare les Case ?
Merci de votre aide
A+

non pas possible.

Par contre :
-> les switch peuvent être remplacés par une bonne conception à base de polymporphisme !!!

Donc oui, c'est faisable!

[koala01]

Salut,

L'une des solutions les plus facile consiste a, si possible, regrouper les deux valeurs de manières à ce qu'elles n'en fassent plus qu'une...

Pour y arriver, il "suffit" de décaler suffisemment "vers la gauche" (en fait, vers le bit de poids fort) la valeur d'une des variable de manière à ce que l'ajout de l'autre ne puisse plus modifier la valeur de la premiere et d'écrire les cas pour chacune des possiblités obtenues...

Je m'explique:

Imaginons que tu veuille effectuer un switch sur les variables a et b, toutes deux déclarées en tant que int, et ayant toutes deux une valeur potentielles comprise entre 0 et 7...

Tu as donc une représentation binaire de l'ordre de

Code :

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

1
2
3
4
5
6
7
8
0 -> 0000
1 -> 0001
2 -> 0010
3 -> 0011
4 -> 0100
5 -> 0101
6 -> 0110
7 -> 0111

Comme tu peux le remarquer, le premier bit qui n'est pas utilisé pour l'instant, c'est le quatrieme

Hé bien, il "suffit" de décaler la valeur d'une des variables de 3 bits...
on pourra apres faire l'addition de a et de b sans perdre l'une des possibilités:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
int finale=a;// j'utilise finale pour ne pas modifier a ;)
finale<<3;   // décalage de trois bits vers la gauche de la valeur de finale
             //(qui était jusqu'à présent la meme que a ;) )
             // En fait, cela revient à multiplier par 8 :D
finale+=b;   // on ajoute la valeur de b à finale...
           // on est sur de ne pas avoir perdu un seul bit de a du fait que
           // le premier bit utilisé pour a se trouve apres le dernier bit 
           // utilisé pour b :D
switch (finale)
{
    case 0: /*a et b valent 0 */ break;
    case 1: /*a  vaut 0 et b vaut 1 */ break;
/* ... */
    case 7: /*a  vaut 0 et b vaut 7 */ break;
    case 8: /*a  vaut 1 et b vaut 0 */ break;
/* ... */
    case 15: /*a  vaut 1 et b vaut 7 */ break;
    case 16: /*a  vaut 2 et b vaut 0 */ break;
/* ... */
    case 23: /*a  vaut 2 et b vaut 7 */ break;
/* ... */
    case 
   case 56: /* a vaut 7 et b vaut 0 */ break;
/* ... */
    case 63 /* a vaut 7 et b vaut 7 */ break;
}

Maintenant, il ne te reste plus qu'à adapter cet exemple à ton cas personnel

[poukill]

Salut,

L'une des solutions les plus facile consiste a, si possible, regrouper les deux valeurs de manières à ce qu'elles n'en fassent plus qu'une...

Pour y arriver, il "suffit" de décaler suffisemment "vers la gauche" (en fait, vers le bit de poids fort) la valeur d'une des variable de manière à ce que l'ajout de l'autre ne puisse plus modifier la valeur de la premiere et d'écrire les cas pour chacune des possiblités obtenues...

Je dois admettre que c'est bien pensé
Mais c'est quand même tordu à souhait ton truc !!

[koala01]

Je dois admettre que c'est bien pensé
Mais c'est quand même tordu à souhait ton truc !!

Pourquoi tordu à souhait

C'est juste une application sensée de la représentation de n'importe quelle valeur en mémoire

[diogene]

PP(Team) :

En faintant :
Tu crée une structure contenant tes 2 types d'éléments, et tu fais un switch de cette structure.
Solution de faciliter qui te prend 3-4 lignes de codes

Sauf qu'on ne peut pas faire un switch sur une structure ou sur un tableau

[Laurent Gomila]

Je dois admettre que c'est bien pensé
Mais c'est quand même tordu à souhait ton truc !!

Pas si tordu que ça, de manière générale c'est très pratique lorsque l'on doit avoir un bloc d'instruction différent par combinaison de variables. Disons que c'est surtout utilisé avec des combinaisons de bits, plutôt que des combinaisons d'entiers.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int collision = (collision_gauche << 3) &
                (collision_droite << 2) &
                (collision_haut   << 1) &
                (collision_bas    << 0);
 
switch (collision)
{
    case 0 : // pas de collision
    case 1 : // collision haut
    case 2 : // collision bas
    case 3 : // collision haut + bas
    ...
    case 15 : // collision de tous les côtés
}

[poukill]

Pas si tordu que ça, de manière générale c'est très pratique lorsque l'on doit avoir un bloc d'instruction différent par combinaison de variables. Disons que c'est surtout utilisé avec des combinaisons de bits, plutôt que des combinaisons d'entiers.

Oui j'ai pas dit que c'était débile du tout... D'ailleurs Koala je ne me souviens pas avoir vu de remarques infondées de ta part!!!
De plus, il est vrai qu'ayant déjà codé des protocoles de transmissions, j'aurai du me rappeler que c'était une technique pratique.
Mais c'est vrai que c'est surtout utilisé en binaire (vrai ou faux)

Mais comme l'a fait remarquer Koala, ça marche aussi avec des nombres plus grands... Ca j'y avais jamais pensé... ^^

[PP(Team)]

Bonjour,
Peut-on faire un switch avec 2 conditions ?
Et comment on déclare les Case ?
Merci de votre aide
A+

En faintant :
Tu crée une structure contenant tes 2 types d'éléments, et tu fais un switch de cette structure.
Solution de faciliter qui te prend 3-4 lignes de codes