La jolie judiciaire de l'opérateur ternaire vs. Si la déclaration
Je parcourt un code et j'ai trouvé quelques opérateurs ternaires dedans. Ce code est une bibliothèque que nous utilisons, et elle est censée être assez rapide.
Je pense que si nous sauvons tout sauf pour l'espace là-bas.
Quelle est votre expérience?
Bien...
J'ai fait quelques tests avec GCC et cette fonction Call:
add(argc, (argc > 1)?(argv[1][0] > 5)?50:10:1, (argc > 2)?(argv[2][0] > 5)?50:10:1, (argc > 3)?(argv[3][0] > 5)?50:10:1);
Le code d'assembleur résultant avec GCC -O3 avait 35 instructions.
Le code équivalent avec des variables intermédiaires if/eus + + + 36. Avec une personne imbriquée si/sinon en utilisant le fait que 3> 2> 1, j'ai eu 44. Je n'ai même pas essayé d'étendre cela dans des appels de fonction distincts.
Maintenant, je n'ai fait aucune analyse de la performance, je n'ai pas fait de vérification de qualité du code d'assembleur résultant, mais à quelque chose de simple comme celui-ci sans aucune boucle E.T.C. Je crois que plus court est meilleur.
Il semble qu'il y ait une certaine valeur pour les opérateurs ternaires après tout :-)
C'est seulement si la vitesse du code est absolument cruciale, bien sûr. Si/eless, des déclarations sont beaucoup plus faciles à lire lorsqu'il est imbriqué à quelque chose comme (C1)? (C2)? (C4)? (C4)?: 1: 2: 3: 4. Et avoir d'énormes expressions comme arguments de fonction est pas amusement.
Gardez également à l'esprit que les expressions ternières imbriquées font refactons le code - ou le débogage en plaçant un tas de prêts pratiques () à une condition - beaucoup plus difficile.
Le seul avantage potentiel pour les opérateurs ternaires par nature si les déclarations à mon avis sont leur capacité à être utilisées pour les initialisations, ce qui est particulièrement utile pour const:
Par exemple.
const int foo = (a > b ? b : a - 10);
Faire cela avec un bloc if/sinon est impossible sans utiliser également une fonction CAL. Si vous avez beaucoup de cas de const, comme celui-ci, vous trouverez peut-être un petit gain d'initialisation d'un const correctement sur la mission avec if/sinon. Mesure le! Probablement ne sera même pas mesurable cependant. La raison pour laquelle j'ai tendance à faire est parce que en marquant le Const, le compilateur sait quand je fais quelque chose plus tard, cela pourrait/changerait accidentellement quelque chose que je pensais être réparé.
Effectivement ce que je dis, c'est que l'opérateur ternaire est important pour la Const-Cidence, et la Const Cidence est une grande habitude d'être dans:
- Cela fait gagner beaucoup de temps en laissant le compilateur vous aider à enregistrer des erreurs que vous faites.
- Cela peut potentiellement laisser le compilateur d'appliquer d'autres optimisations
Vous supposez qu'il -doit être une distinction entre les deux quand, en fait, il existe un certain nombre de langues qui renoncent à la déclaration "if-sinon" en faveur d'une expression "si-autre" (dans Ce cas, ils ne peuvent même pas avoir l'opérateur ternaire, ce qui n'est plus nécessaire)
Imaginer:
x = if (t) a else b
Quoi qu'il en soit, l'opérateur ternaire est une expression dans certaines langues (C, C #, C++, Java, etc.) qui font non ont des expressions "si-d'autre" et donc sert un rôle distinct là.
Si vous êtes inquiet à ce sujet dans une perspective de performance, je serais très surpris s'il y avait des différents entre les deux.
De l'apparence, nez la perspective, il est principalement bas à la préférence personnelle. Si la condition est courte et que les parties vraies/fausses sont courtes, un opérateur ternaire va bien, mais quelque chose de plus long a tendance à être meilleur dans une déclaration if/else (à mon avis).