Преимущества использования условного выражения?: (троичный) оператор

Если вам нужно несколько ветвей с одним и тем же условием, используйте if:

if (A == 6)
  f(1, 2, 3);
else
  f(4, 5, 6);

Если вам нужно несколько ветвей с разными условиями, тогда, если количество операторов будет снежным комом, вы захотите использовать тройной:

f( (A == 6)? 1: 4, (B == 6)? 2: 5, (C == 6)? 3: 6 );

Кроме того, вы можете использовать тернарный оператор при инициализации.

const int i = (A == 6)? 1 : 4;

Делать это с помощью if очень беспорядочно:

int i_temp;
if (A == 6)
   i_temp = 1;
else
   i_temp = 4;
const int i = i_temp;

Вы не можете поместить инициализацию внутри if / else, потому что это меняет область видимости. Но ссылки и константные переменные могут быть связаны только при инициализации.

Сценарий, который я чаще всего использую, это для значений по умолчанию и особенно для возвратов

return someIndex < maxIndex ? someIndex : maxIndex;

Это действительно единственные места, где я мне это приятно, но для них я люблю.

Хотя, если вы ищете логическое значение, это может иногда выглядеть уместным:

bool hey = whatever < whatever_else ? true : false;

Потому что это так легко читать и понимать, но эту идею всегда следует отбрасывать в пользу более очевидного:

bool hey = (whatever < whatever_else);

Я бы рекомендовал ограничить использование тернарного оператора (? :) простым однострочным назначением логики if / else. Что-то похожее на этот шаблон:

if(<boolCondition>) {
    <variable> = <value>;
}
else {
    <variable> = <anotherValue>;
}

Можно легко преобразовать в:

<variable> = <boolCondition> ? <value> : <anotherValue>;

Я бы избегал использования тернарного оператора в ситуациях, требующих if / else if / else, вложенной логики if / else или if / else, которая приводит к оценка нескольких строк. Применение тернарного оператора в таких ситуациях, скорее всего, приведет к нечитаемому, сбивающему с толку и неуправляемому коду. Надеюсь это поможет.

Использование оператора? оператор в например. MS Visual C ++, но это действительно специфическая вещь для компилятора. В некоторых случаях компилятор действительно может оптимизировать условную ветвь.

Преимущество условного оператора в том, что он является оператором. Другими словами, он возвращает значение. Поскольку if является оператором, он не может возвращать значение.

Если я устанавливаю значение и знаю, что для этого всегда будет одна строка кода, я обычно использую тернарный (условный) оператор. Если есть шанс, что мой код и логика изменятся в будущем, я использую if / else, поскольку это более понятно другим программистам.

Возможно, вас еще интересует ?? оператор .

При использовании тернарного оператора следует понимать, что это выражение, а не утверждение.

В функциональных языках, таких как схема, различие не существует:

(if (> a b) a b)

Условный?: Оператор «Не кажется таким гибким, как конструкция if / else»

В функциональных языках это так.

При программировании на императивных языках я применяю тернарный оператор в ситуациях, когда я обычно использую выражения (присваивание, условные операторы и т. Д.).

Действительно классное использование:

x = foo ? 1 :
    bar ? 2 :
    baz ? 3 :
          4;

Условный оператор отлично подходит для коротких условий, например:

varA = boolB ? valC : valD;

Я использую его иногда, потому что для написания чего-то таким образом требуется меньше времени ... к сожалению, это ветвление иногда можно упустить другим разработчиком, просматривающим ваш код. Кроме того, код обычно не такой короткий, поэтому я обычно улучшаю читаемость, добавляя? и: в отдельных строках, например:

doSomeStuffToSomething(shouldSomethingBeDone()
    ? getTheThingThatNeedsStuffDone()
    : getTheOtherThingThatNeedsStuffDone());

Однако большое преимущество использования блоков if / else (и почему я предпочитаю их) состоит в том, что легче войти позже и добавить некоторую дополнительную логику в ветку,

if (shouldSomethingBeDone()) {
    doSomeStuffToSomething(getTheThingThatNeedsStuffDone());
    doSomeAdditionalStuff();
} else {
doSomeStuffToSomething(getTheOtherThingThatNeedsStuffDone());
}

или добавьте другое условие:

if (shouldSomethingBeDone()) {
    doSomeStuffToSomething(getTheThingThatNeedsStuffDone());
    doSomeAdditionalStuff();
} else if (shouldThisOtherThingBeDone()){
    doSomeStuffToSomething(getTheOtherThingThatNeedsStuffDone());
}

Итак, в конце концов, речь идет об удобстве для вас сейчас (короче:?) против удобства для вас (и других) позже. Это суждение ... но, как и все другие проблемы с форматированием кода, единственное реальное правило - быть последовательным и быть визуально вежливым по отношению к тем, кто должен поддерживать (или оценивать!) Ваш код.

(весь код скомпилирован на глаз)

Я нахожу это особенно полезным при веб-разработке, если я хочу установить для переменной значение, отправленное в запросе, если оно определено, или какое-то значение по умолчанию, если это не так.

Это в значительной степени охвачено другими ответами, но "это выражение" не объясняет, почему это так полезно...

В таких языках, как C++ и C#, вы можете определить локальные поля, доступные для чтения (в теле метода), используя их. Это невозможно с помощью обычного оператора if/then, потому что значение поля readonly должно быть присвоено в рамках этого единственного оператора:

readonly int speed = (shiftKeyDown) ? 10 : 1;

это не то же самое, что:

readonly int speed;  
if (shifKeyDown)  
    speed = 10;    // error - can't assign to a readonly
else  
    speed = 1;     // error  

Подобным образом вы можете встроить третичное выражение в другой код. Помимо того, что это делает исходный код более компактным (и в некоторых случаях более читаемым), это также может сделать сгенерированный машинный код более компактным и эффективным:

MoveCar((shiftKeyDown) ? 10 : 1);

...может сгенерировать меньше кода, чем если бы пришлось вызывать один и тот же метод дважды:

if (shiftKeyDown)
    MoveCar(10);
else
    MoveCar(1);

Конечно, это также более удобная и лаконичная форма (меньше опечаток, меньше повторений, и может уменьшить вероятность ошибок, если вам приходится дублировать куски кода в if/else). В чистых случаях "общего шаблона", таких как этот:

object thing = (reference == null) ? null : reference.Thing;

... его просто быстрее читать/разбирать/понимать (как только вы привыкнете к нему), чем длинный эквивалент if/else, поэтому он может помочь вам быстрее "понять" код.

Конечно, только потому, что он полезен, не означает, что его лучше всего использовать в каждом случае. Я бы посоветовал использовать его только в коротких фрагментах кода, где смысл ясен (или более ясен) с помощью ?: - если вы используете его в более сложном коде или вставляете троичные операторы друг в друга, это может сделать код ужасно трудным для чтения.

Обычно я выбираю троичный оператор, если в противном случае у меня будет много дублирующегося кода.

if (a > 0)
    answer = compute(a, b, c, d, e);
else
    answer = compute(-a, b, c, d, e);

С помощью троичного оператора это можно сделать следующим образом.

answer = compute(a > 0 ? a : -a, b, c, d, e); 

Тернарный оператор может быть включен в rvalue, тогда как if-then-else не может; с другой стороны, if-then-else может выполнять циклы и другие операторы, тогда как тернарный оператор может выполнять только (возможно, недействительные) rvalue.

В соответствующем примечании, && и || Операторы позволяют использовать некоторые шаблоны выполнения, которые сложнее реализовать с помощью if-then-else. Например, если у кого-то есть несколько функций для вызова и он хочет выполнить фрагмент кода в случае сбоя какой-либо из них, это можно сделать с помощью оператора &&. Выполнение этого без этого оператора потребует либо избыточного кода, либо goto, либо дополнительной переменной-флага.