Discussion :

[r0d]

Bonjour à tous,

j'ai trouvé diverses discussions sur ce sujet, mais rien sur dvp. Alors voilà, je me lance:

Prenons le code suivant:

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
void UneClasse::MethodeIf(int i)
{
   if (i==0)
   {
   <code>
   }
   else if (i==1)
   {
   <code>
   }
   [...]//etc
   else
   {
   <code>
   }
}

et le code suivant:

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
void UneClasse::MethodeSwitch(int i)
{
switch (i)
   {
   case 0:
      <code>
   break;
   case 1:
      <code>
   break;
   [...]//etc
   default:
 
   }
}

Voici mes questions:
1/ Quelle méthode sera la plus rapide à l'exécution? Y a-t-il des exeptions?
2/ Comment fonctionne la génération de code pour un switch (au niveau du compilateur) ?
3/ Si l'on met de côté les problèmes d'efficacité (et de lisibilité du code), quels sont les avantages/inconvénients de ces 2 méthodes?

Merci pour vos réponses

[Fiquet]

Je suis pas un pro de ce gendre d'optimisations mais en théorie on dit que les switch sont plus rapide. Mais bon j'ose espérer qu'à ce niveau là le compilateur peut optimiser de lui-même.

Bref pour du code comme ça c'est clair que j'utiliserais un switch qui en plus est plus intuitif, donc je vois pas de désavantage ici.

[Jean-Marc.Bourguet]

Voici mes questions:
1/ Quelle méthode sera la plus rapide à l'exécution? Y a-t-il des exeptions?

Il faut mesurer. Il y a de bonnes chances que le switch soit plus rapide mais j'imagine sans probleme des cas ou les if en cascade le sont.

2/ Comment fonctionne la génération de code pour un switch (au niveau du compilateur)?

Differentes techniques sont possibles, et generalement le compilateur choisi celle qui a le plus de chances d'etre la plus efficaces. Les 3 les plus connues:

• les if en cascade de maniere sequentielle
• des if en cascade implementant une recherche binaire
• un saut indirect

[Matthieu Brucher]

Avantage du if : la versatilité des tests, tu peux tester contre n'importe quoi, y compris un résultat précedent
Avantage du switch : permettre d'exécuter "en cascade" du code, par exemple si on exécute du code pour i >=3, mais pour i = 2, il y a d'autres choses à faire avant, et pour i=1, il y a le code de i>=3 et i=2, avec un switch, c'est immédiat et plus lisible que les if qui vont avec - et il y a moins de tests apparents aussi -

[r0d]

merci pour votre participation

... Une aute question, qui finalement se contente de préciser celles qui sont déjà posées:
- Dans le switch, s'il l'on prend mon exemple de code et qu'on est dans le cas ou i=10. Va-t-on passer 10 fois sur un test de type "if (i==x)" ou va-t-on directement à l'endroit où se trouve le code du 'case' correspondant?

(J'ai l'impression que J.M. Bourquet a répondu à cette question, mais je n'ai pas bien compris votre réponse et je n'ai pas eu le temps de me renseigner. Je voulais juste poster cette dernière question avant de partir en week-end, au cas où).

Sur ce, bon week-end à tous!

[Jean-Marc.Bourguet]

- Dans le switch, s'il l'on prend mon exemple de code et qu'on est dans le cas ou i=10. Va-t-on passer 10 fois sur un test de type "if (i==x)" ou va-t-on directement à l'endroit où se trouve le code du 'case' correspondant?

On peut aller directement au dixieme cas avec la troisieme methode que j'ai donnee.

[vdumont]

Perso je trouve également que le switch est plus facile à lire.

[swirtel]

1) Un switch est plus rapide à interprété durant l'exécution
2) Concernant la lecture d'un switch effectivement c'est plus simple car les conditions sont unitaires et ne savent pas être composée.

Il y a peut-être des optimisations faites pour le if, mais c'est certainement en fonctions des expressions à évaluer.

[Charlemagne]

Je suis d'accord grosso modo sur ce qui a été dit plus haut.
On peut quand même parfois utiliser des probas sur la variable pour optimiser le code.
(ma source: Intel Architecture Optimization Reference Manual)

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int n=rand();
if (!(n&0x01)) n=0; // n est nul la moitié du temps
switch(n)
{
  case 0: handle_0(); break;
  case 1: handle_1(); break;
  case 3: handle_3(); break;
  default: handle_other();
}

Ca peut être optimisé par le code suivant car meilleure prédiction de branchement. Il faut savoir que les Pentiums prédisent que la condition du "if" est satisfaite.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
int n=rand();
if (!(n&0x01)) n=0; // n est nul la moitié du temps
if (!n) handle_0();
else
switch(n)
{
  case 1: handle_1(); break;
  case 3: handle_3(); break;
  default: handle_other();
}

[outs]

Mais bon j'ose espérer qu'à ce niveau là le compilateur peut optimiser de lui-même.

Non le principe du C++ est que tu doit faire les optimisation de ce genre toi même.

La question du if vs switch a été répondue plus haut (c'est d'ailleur un problème du C et non pas du C++)

Par contre si tu a un grand nombre de cas possible que se ressemblent (je dirais plus de 5) pose toi la question d'implémenter ca avec une boucle, un tableau ou une fonction. Il faut éviter de coder des choses en *dur* dans le code. mais plutot essayer de faire un code générique.