Discussion :

[socrate]

Bonjour

J'ai un code du type:

Code :

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

1
2
3
4
5
6
7
8
9
switch(x)
{
case 0:
  traitement 0;
  break;
...
case n:
  traitement_n;
}

Tous les cas (0, 1, ..., n) sont traités. Je me demandais si ca ne serait pas mieux de faire un tableau de fonctions:

FONCTION f[n];
comme ca, connaissant x, je n'ai qu'a faire f[x] au lieu du grand switch. Je pense que ce serait plus rapide a l'exécution. Comme mon n est assez grand, mais j'aimerais avoir une petite idée avant de me lancer la dedans
Ca ne me dérange pas que le code généré grossise.
Je pars du principe qu'un switch est plus lent car il demande un certain nombre de comparaison.
Qu'en pensez vous?

[diogene]

Bonsoir
Je suis favorable personnellement à la solution d'un tableau de pointeur sur fonctions dans cette situation. Non d'ailleurs pour un problème de rapidité d'exécution (si ce n'est pas critique, mais de toute façon je pense que c'est effectivement plus rapide), mais plutôt pour obtenir une structuration et une lisibilité du programme plus grande : chaque traitement se trouve parfaitement localisé dans une fonction ; chaque traitement est traité indépendamment des autres; chaque traitement est parfaitement identifiable, quel que soit sa complexité; sa lisibilité n'est plus affecté par la complexité du traitement des autres cas.

Ca ne me dérange pas que le code généré grossise

Je ne crois même pas que cette solution présente cet inconvénient, au contraire.

Comme mon n est assez grand,

Une raison supplémentaire, ce switch va devenir illisible
C'est une solution que j'adopterais très probablement

[Trap D]

Oui, c'est surement le mieux.
C'est beaucoup plus simple, lisible et facilement extensible..

[hegros]

pour faire un tableau de pointeur sur fonction il faudrait encore que les n fonctions aient la meme signature ou au minimum chacune recevant un nombre d'argument equivalent ou alors ca risque d'etre un peu plus complexe...

[socrate]

Merci les gars, je vais faire ca... Ya pas de pb a propos de la signature

[hegros]

Merci les gars, je vais faire ca... Ya pas de pb a propos de la signature

Essai de poser du code dans le cas ou tu bloques

[Emmanuel Delahaye]

J'ai un code du type:

Code :

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

1
2
3
4
5
6
7
8
9
switch(x)
{
case 0:
  traitement 0;
  break;
...
case n:
  traitement_n;
}

Tous les cas (0, 1, ..., n) sont traités. Je me demandais si ca ne serait pas mieux de faire un tableau de fonctions:

FONCTION f[n];
comme ca, connaissant x, je n'ai qu'a faire f[x] au lieu du grand switch. Je pense que ce serait plus rapide a l'exécution. Comme mon n est assez grand, mais j'aimerais avoir une petite idée avant de me lancer la dedans
Ca ne me dérange pas que le code généré grossise.
Je pars du principe qu'un switch est plus lent car il demande un certain nombre de comparaison.

Ce serait le pire des cas. Il y a de fortes chances que ce soit plutôt une table de sauts indexés, surtout si les valeurs des 'cases' sont consécutives et classées en ordre croissant. Ca dépend du compilateur.

Oui, un tableau de fonction est possible si les index sont clairs et ne changent pas, c'est à dire indépendants des specifications externes de l'application...

[Bayard]

Attention tout de même à vérifier la valeur de l'index dans la cas d'un tableau de fonction. Il faut tester si sa valeur ne dépasse pas la table.

Dans le cas d'un switch, le poblème ne se pose pas même si la gestion d'un "défault" peut être pertinente (avec une trace si c'est possible).

[socrate]

Je mets ce message pour dire que ca marche bien avec les fonctions virtuelles, je vais donc enlever mon switch. Je mets le code si ca peut intéresser quelqu'un:

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
28
29
30
31
32
 
#include <iostream>
 
using namespace std;
 
class A
{
  typedef void (A::*FONCTION)();
  static FONCTION fct[];
  virtual void f() {cout << "A::f()" << endl;}
  void g() {cout << "A::g()" << endl;}
public:
  void test(int n) 
  {
    FONCTION f = fct[n];
    this->f();
  }
};
 
A::FONCTION A::fct[] = {&A::f, &A::g};
 
class B: public A
{
  virtual void f() {cout << "B::f()" << endl;}
};
 
int main()
{
  A* a = new B();
  a->test(0); // Appel de B::f()
  delete a;
}

[Swoög]

oublie pas le petit résolu en bas à gauche

[Trap D]

Et on a bossé pour un type qui fait du C++ !!!

[socrate]

J'étais pas courant de la guerre entre le C et le C++
De toutes facons, c'était pas volontaire

[Trap D]

Ce n'est pas une guerre loin de là , mais il faut faire attention ,les deux langages se ressemblent mais sont pourtant assez différents, d'où la nécessité de 2 forums.