[Principe de programmation] switch / case [Résolu]

[dranduncandane]

Ma question de concerne pas vraiment les Design Patterns ni une méthode mais je ne vois pas ou l'a poster mieux qu'ici.

Voilà, je voudrais savoir s'il est possible d'optimiser ce genre d'algorithmes :

Code :

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
28
29
30
31
32
33
34
switch (var)
{
  case 1:
  switch (subvar)
  {
    case a:
      process a1;
    case b:
      process b1;    
    case c:
      process c1;
  }
  case 2:
  switch (subvar)
  {
    case a:
      process a2;
    case b:
      process b2;    
    case c:
      process c2;
  }
  case 3:
  switch (subvar)
  {
    case a:
      process a3;
    case b:
      process b3;    
    case c:
      process c3;
  }
}

Le code est assez simple ici mais il faut l'imaginer plus complexe. Avec plus de case et avec plus de niveau de switch. J'ai le cas avec 3 variables. Selon qu'elles prennent les valeurs 1, 2, 3 ou a, b, c ou alpha, beta, charlie j'ai des processus différents à réaliser. Est il possible d'optimiser celà d'une autre manière que vie une série de switch / case ?

[Baptiste Wicht]

Oui, tu peux l'optimiser et faire ça de manière bien plus propre. Tu peux pas exemple utiliser une "Chain of responsability" avec une Factory :

Code Java :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class ProcessFactory {
	private ArrayList<Process> processses = null;
 
	public ProcessFactory(){
		super();
 
		processses = new ArrayList<Process>();
 
		processses.add(new ProcessC1());
		processses.add(new ProcessC2());
		processses.add(new ProcessC3());
		processses.add(new ProcessC4());					processses.add(new ProcessC5(6));					processses.add(new ProcessC5(22));
	}
 
	public Process getProcess(int var, int subvar){
		for(Process process : processses){
			if(process.canDo(var, subvar)){
				return process;
			}
		}
 
		return null;
	}
}

Ensuite, il suffit que tes process implémentent tous une interface process avec une canXXX et tu pourras ensuite facilement l'utiliser :

Code Java :

new ProcessFactory().getProcess(var, subvar).launch();

Là le code est en Java, mais tu dois pouvoir adapter ça à tous les langages.

[rhadamanthe]

Si tu écris cela en C, la méthode évoquée un peu plus haut risque de te causer pas mal de developpement pour l'adapter !!

De façon plus simple, tu peux remplacer les switch imbriqués par des appels à des fonctions

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
switch (var)
{
  case 1:
  fonctionSwitch1(...)
  case 2:
  fonctionSwitch2(...)
  case 3:
  fonctionSwitch3(...)
}

fonctionSwitch1(...){
   switch (subvar)
  {
    case a:
      process a1;
    case b:
      process b1;    
    case c:
      process c1;
  }
}

etc...

En faisant cela tu risques de pouvoir factoriser du code. Cela améliore la lisibilité du code et du coup il est plus facile à maintenir.
Optimiser est difficile car tu sera obligé à un moment ou un autre de faire ces tests. Si cela n'est n'est avec un switch, ça sera avec un if/else etc...

[Baptiste Wicht]

C'est clair que si tu codes en C, la façon de faire que je t'ai donnée ne vas pas être possible, le C n'étant pas orienté objet

Je ne vois alors que la solution de rhadamanthe.

Ah ces langages non-orientés objets

[alex00]

Bonjour,

c'est le genre de chose qui se fait tres bien avec des tableaux de pointeurs sur fonctions

Code :

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
28
29
30
31
/* exemple limite a 2 indices, reduits a un tableau a 1 dimension pour faire simple */

#include <stdio.h>
                                                                                                                                                                                                     
typedef void (*T_F)();
                                                                                                                                                                                                     
/* les fonctions a appeler en fonction des parametres */
void f1a () { printf("f1a\n"); }
void f1b () { printf("f1b\n"); }
void f2a () { printf("f2a\n"); }
void f2b () { printf("f2b\n"); }
                                                                                                                                                                                                     
static T_F functions[4] = { &f1a, &f1b, &f2a, &f2b } ;
                                                                                                                                                                                                     
/* usage: a.out 1|2 a|b */
int main(int argc, char** argv) {
                                                                                                                                                                                                     
   /* bidouille sur les agruments pour cet exemple */
   if (argc < 2) return -1;
   int v1 = (argv[1][0] -1) & 1;
   int v2 = (argv[2][0] -1) & 1;
   int index = (v1 << 1) | v2;
   /* printf ("%d, %d, %d\n", v1, v2, index); */

   /* ici la partie interessante */
   T_F f = functions[index];
   (*f)();

   return 0;
}

Alex.

[rhadamanthe]

Le problème avec la méthode des pointeurs de fonction, c'est qu'il n'est pas certain du tout que l'index soit si simple à déterminer.

Si pour chaque valeur de son switch il doit déterminer la correspondance en indice, cela risque d'etre vite laborieux. (maintenir un tableau des correspondances, pire, faire un hachage...)

Tant qu'a faire les tests, autant appeler directement la fonction qui va bien je pense.

[dranduncandane]

Merci pour toutes vos réponses. j'ai trouvé celà fort intéressant. Je développe en C#. Je peux donc choisir l'option orienté objet en évitant les pointeurs. La solution de wichtounet semble tout à fait appropriée à mes besoins.

C'est incroyable. Je peux réduire tout mes switch/case, if/else en un unique if. C'est évidement beaucoup plus propre.

Celà me fait penser à un une remarque que j'ai lu il y a un petit temps. Est il vrai qu'un bon programme orienté objet (voir pur objet) devrait comporter un minimum (voir aucune) d'alternatives ?