Discussion :

[ternel]

En C++, on a un certain nombre d'instructions qui ont un équivalent sous forme d'une instruction.

par exemple, if (cond) value = a; else value = b; peut s'écrire value = cond ? a : b;.
De même, on a les opérateurs de stream (au lieu d'appels successifs à printf/scanf), les lambdas, et d'autres choses.

Par ailleurs, j'ai remarqué que la majorité des switchs que j'écris sont de la forme

Code :

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

1
2
3
4
5
switch(bidule) {
  case 1: a = enum_value_1; break;
  case 2: a = enum_value_2; break;
  default: a = enum_value_failure;
}

Après discussions avec plusieurs collègues, on s'est dit qu'on pourrait imaginer une opération équivalente:
quelque chose comme: a = {1, 2, ...}->{enum_value_1, enum_value_2, enum_value_failure};Ce type de notation pourrait aussi servir dans la liste d'initialisations des constructeurs.

Parmi les questions au dela du sondage, il y a:
quelle notation utiliser?
quelles restrictions placer?

N'hésitez pas à expliquer votre point de vue, la discussion n'en sera que plus intéressante.

[Bousk]

Si les valeurs sont contigües, tu peux le remplacer par un array static et un index directement : a = as[bidule <= as.size() ? bidule : 0]; avec un Array<> as = {failure, value1, value2};
Sinon un template c'est pas évident, puisque bidule et switch sont évalués au runtime et non à la compilation.

[ternel]

Le problème du tableau, c'est qu'effectivement, il faut des valeurs contigües, mais aussi que les objets cibles soient constructibles à l'avance (ce qui est problable), copiables (et non simplement déplaçables).
De plus, il faut aussi que le type de la clé ne puisse pas être négatif, ce qui n'est que rarement le cas pour une enum.


J'ai commencé à chercher une forme template qui serait pratique. Le problème me fait penser à l'optimisation qu'on peut rencontrer dans les "expressions templates".
Je sens venir le gros creusage de méninges.

[Matt_Houston]

Laisse tomber le C++..?

Quelque chose de ce style ?

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
33
34
35
36
37
#include <iostream>
 
 
template <typename In, typename Out = In>
Out match(In value, Out def, In a_in, Out a_out) {
    if (value == a_in) return a_out;
 
    return def;
}
 
template <typename In, typename Out, typename ...Args>
Out match(In value, Out def, In a_in, Out a_out, In b_in, Out b_out, Args ...args) {
    if (value == a_in) return a_out;
    if (value == b_in) return b_out;
 
    return match(value, def, args...);
}
 
 
int main() {
    std::cout <<
        match(3.0,
                        "inconnu",
              2.5     , "deux virgule cinq",
              3.141592, "pi",
              3.0     , "trois point zéro")
              << std::endl;
    std::cout <<
        match(4.0,
                        "inconnu",
              2.5     , "deux virgule cinq",
              3.141592, "pi",
              3.0     , "trois point zéro")
              << std::endl;
 
    return 0;
}

Code :

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

1
2
3
4
$ g++ -std=c++14 -pedantic -Wall -Wextra main.cpp
$ ./a.out
trois point zéro
inconnu

[Bousk]

Certes ça fait le job mais tu remplaces un switch, qui est un simple jmp par une succession de if, donc tu tues tes perfs au passage

[ternel]

En effet, ca pourrait s'y apparenter.

[Matt_Houston]

Certes ça fait le job mais tu remplaces un switch, qui est un simple jmp par une succession de if, donc tu tues tes perfs au passage

Tu tues les perfs.. mouais c'est emphatique mais soit, car les cases ne sont pas des constantes entières comme dans un switch. On pourrait passer les valeurs in en arguments template mais il va falloir se montrer ingénieux pour que ce soit générique (pas de nombres à virgule flottante nus, par exemple).

[JolyLoic]

Si tout ce que tu veux est une expression, tu dois pouvoir passer par une lambda:

Code :

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

1
2
3
4
5
a = [](int b){switch(b) 
  {
  case 1: return enum_value_1;
  case 2: return enum_value_2;
  }(bidule);

Si ce que tu veux est aussi une écriture plus simple... Peut-être boost.pp?
J'ai peur qu'une autre solution (par exemple, une simple map remplie une fois à la création du programme...) ne te permette pas d’avoir les mêmes performances qu'un switch...

[ternel]

L'un des arguments que j'avais pour la création d'une syntaxe spécifique, c'est que les valeurs expressions résultat non choisies ne devraient pas être évaluées (à l'instar du ternaire).

Ta solution d'une lambda évaluée sur place rempli ce besoin, mais il y a peut-être un coup en performance.
Par contre, c'est vrai que niveau "bruit", ca reste bourré de case et de return.