La beauté de l'opérateur ternaire contre si l'instruction

Performance

L'opérateur ternaire ne présentent pas de différences dans les performances d'un bien équivalent écrit if/else déclaration... ils peuvent bien se résoudre à la même représentation de l'Arbre de Syntaxe Abstraite, à subir les mêmes optimisations, etc..

Choses que vous ne pouvez faire avec ? :

Si vous êtes en cours d'initialisation d'une constante ou de référence, ou de la valeur à utiliser à l'intérieur d'un membre de l'initialisation de la liste, puis if/else déclarations ne peuvent pas être utilisés, mais ? : peut être:

const int x = f() ? 10 : 2;

X::X() : n_(n > 0 ? 2 * n : 0) { }

Affacturage pour code concis

Clés raisons d'utiliser ? : inclure la localisation, et en évitant la redondance de répéter les autres parties de la même consolidés/fonction-les appels, par exemple:

if (condition)
    return x;
else
    return y;

...n'est préférable à...

return condition ? x : y;

...sur la lisibilité des motifs si vous traitez avec très peu d'expérience des programmeurs, ou certains de ces termes sont assez compliqué pour le ? : structure se perdent dans le bruit. Dans des cas plus complexes comme:

fn(condition1 ? t1 : f1, condition2 ? t2 : f2, condition3 ? t3 : f3);

Un équivalent if/else:

if (condition1)
    if (condition2)
        if (condition3)
            fn(t1, t2, t3);
        else
            fn(t1, t2, f3);
    else if (condition3)
            fn(t1, f2, t3);
        else
            fn(t1, f2, f3);
else
    if (condition2)
       ...etc...

C'est beaucoup d'extra appels de fonction, le compilateur peut ou ne peut pas optimiser loin.

Ne peut pas nommé temporaires améliorer le si/d'autre monstruosité ci-dessus?

Si les expressions t1, f1, t2 etc. sont trop verbeux pour taper à plusieurs reprises, la création d'nommé temporaires peuvent aider, mais alors:

• De performance correspondant ? : vous pouvez avoir besoin d'utiliser std::move, sauf lorsque le même temporaire, est passé à deux && paramètres dans la fonction appelée: ensuite, vous devez l'éviter. C'est plus complexe et sujette à erreur.

• c ? x : y évalue c alors, soit, mais pas les deux de x et y, ce qui le rend sûr pour dire que le test d'un pointeur n'est pas nullptr avant de l'utiliser, tout en procurant une certaine valeur de repli et/ou du comportement. Le code ne reçoit que les effets secondaires de celui de x et y est effectivement sélectionné. Avec nommée temporaires, vous pouvez avoir besoin if /else autour ou ? : à l'intérieur de leur initialisation non désiré de l'exécution du code, ou une exécution de code plus souvent que souhaité.

Différence fonctionnelle: unifier le type de résultat

Considérer:

void is(int) { std::cout << "int\n"; }
void is(double) { std::cout << "double\n"; }

void f(bool expr)
{
    is(expr ? 1 : 2.0);

    if (expr)
        is(1);
    else
        is(2.0);
}

Dans l'opérateur conditionnel version ci-dessus, 1 subit une Conversion Standard de double de sorte que le type appariés 2.0, sens de la is(double) surcharge, même pour les true/1 situation. Le if/else déclaration ne donne pas lieu à cette conversion: le true/1 direction générale des appels is(int).

Vous ne pouvez pas utiliser des expressions avec un ensemble du type de void dans un opérateur conditionnel soit, alors qu'ils sont valides dans les déclarations en vertu d'un if/else.

L'accent: la valeur de sélection avant/après d'action nécessitant des valeurs

Il y a un accent différent:

Un if/else déclaration souligne la ramification de la première et de ce qui est à faire est secondaire, alors qu'un opérateur ternaire souligne que faut-il faire sur la sélection des valeurs à le faire avec.

Dans différentes situations, que ce soit de mieux refléter le programmeur "naturelles" de point de vue sur le code et le rendre plus facile à comprendre, de vérifier et de maintenir. Vous pouvez trouver vous-même la sélection de l'un sur l'autre en fonction de l'ordre dans lequel vous tenez compte de ces facteurs lors de l'écriture du code - si vous vous êtes lancé dans le "faire quelque chose", puis trouver, vous pouvez utiliser un couple (ou peu) les valeurs de le faire avec, ? : est la moins perturbatrice façon d'exprimer que, et de continuer votre codage "flux".

Le seul avantage potentiel pour le ternaire des opérateurs sur la plaine si les déclarations de mon point de vue est leur capacité à être utilisés pour les initialisations, ce qui est particulièrement utile pour const:

E. g.

const int foo = (a > b ? b : a - 10);

De faire ça avec un if/else bloc est impossible sans l'aide d'une fonction cal ainsi. S'il vous arrive d'avoir beaucoup de cas de const choses comme ce que vous pourriez trouver il y a un petit gain de l'initialisation d'un const correctement sur cession avec if/else. Mesurer! Ne sera probablement même pas être mesurable si. La raison que j'ai tendance à faire, c'est parce qu'en le marquant const le compilateur sait quand je fais quelque chose de plus tard qui pourrait/serait accidentellement modifier quelque chose que je pensais était fixe.

Effectivement ce que je dis, c'est que l'opérateur ternaire est important pour la const-correct, et l'const exactitude est une excellente habitude à être dans:

1. Cela permet d'économiser beaucoup de votre temps en laissant le compilateur vous aide à repérer les erreurs que vous faites
2. Cela peut potentiellement permettre au compilateur de s'appliquer à d'autres optimisations

Si vous êtes inquiet à ce sujet à partir d'un point de vue des performances alors je serais très surpris s'il y avait une différence entre les deux.

D'un look 'n sentons point de vue, c'est surtout vers le bas à la préférence personnelle. Si la condition est court et le vrai/faux les parties sont courtes, puis d'un opérateur ternaire est très bien, mais rien de plus tend à être meilleure dans un if/else (à mon avis).