Fabien LE LEZ a écrit :

On Tue, 15 Jan 2008 18:02:02 +0100, Lea GRIS :

static char * sorties[ ] = { "OK","EN","SU","AN","ND" };

Je préférerais un
static char* sorties[2][2][2][2]= ...

char * gettest(bool dfi,dft,dds,dfs)
{

   return sorties [dfi][dft][dds][dfs];

Mais bon, c'est un détail.

De plus, l'indexation d'une table de vérité resterait-elle plus
avantageuse lorsque la complexité des conditions augmente en
considération d'un environnement moderne (cache L1-L2, pipelining,
prédictions des branchements, RAM significativement plus lente que le
CPU...).

Franchement, vu la complexité des architectures récentes, on ne peut
pas savoir. Faut implémenter les deux méthodes et faire des tests de
performances.
Et la plupart du temps, les tests indiquent que la différence réelle
est très faible en pratique, et qu'il vaut mieux pondre le code le
plus lisible.

Comme le code que j'ai publié hier était cochon et erroné, je remet ici
un code propre et qui fonctionne. J'espère pouvoir bientôt comparer les
deux algorithmes. En attendant voici la version avec table :

#include <stdbool.h>
#include <string.h>
#include <stdio.h>

/* Représentations binaires des différentes valeurs d'entrées
 * en vue de leur assemblage comme index entier.
 */
#define DFI 0x01
#define DFT 0x02
#define DDS 0x04
#define DFS 0x08

/* Les différentes valeurs de sorties sont des chaînes
 * de caractères mais il serait aussi possible d'y ranger
 * des pointeurs vers la fonction à appeler conditionnellement
 * à la valeur d'index.
 */
static char *sorties[] = { "OK", "En cours", "Suspendu", "Annulé", "N-D" };

/* Table de vérités */
static unsigned int verites[] =
  { 1, 0, 0, 0, 2, 3, 3, 3, 4, 4, 4, 4, 2, 0, 0, 0 };

char *
dotest1 (bool dfi, bool dft, bool dds, bool dfs)
{
/* Assemble l'index entier avec les valeurs binaires conditionnelles
 * et retourne la valeur de sortie trouvée dans la table de verites
 */
  int i =
    (dfi ? DFI : 0) | (dft ? DFT : 0) | (dds ? DDS : 0) | (dfs ? DFS : 0);

/* Le code suivant serait équivalent tant que l'implémentation
 * du type bool vaut 0 pour faux et 1 pour vrai.
 * En pratique je ne sais pas si c'est fiable et cela n'apporte
 * aucune optimisation algorithmique.
 * Je le laisse en exemple :
 *
 * i = dfi*DFI | dft*DFT | dds*DDS | dfs*DFS;
 */
  int verite = verites[i];
  return (sorties[verite]);
}

int
main (int argc, char *argv[])
{
  int i;
  bool dfi = false;
  bool dft = false;
  bool dds = false;
  bool dfs = false;

  for (i = 1; i < argc; i++)
    {
      if (strncasecmp ("DFI", argv[i], 3) == 0)
dfi = true;
      if (strncasecmp ("DFT", argv[i], 3) == 0)
dft = true;
      if (strncasecmp ("DDS", argv[i], 3) == 0)
dds = true;
      if (strncasecmp ("DFS", argv[i], 3) == 0)
dfs = true;
    };

  printf ("DFI %s\n", (dfi ? "VRAI" : "FAUX"));
  printf ("DFT %s\n", (dft ? "VRAI" : "FAUX"));
  printf ("DDS %s\n", (dds ? "VRAI" : "FAUX"));
  printf ("DFS %s\n", (dfs ? "VRAI" : "FAUX"));

  printf ("Résultat : %s\n", dotest1 (dfi, dft, dds, dfs));
  return (0);
}

--
Léa Gris