Действительно ли это - разумное использование тернарного оператора? [закрытый]

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

if (cond) doIt();

cond ? noop() : doIt();

Принимая во внимание, что следующее намного более хорошо ступить через (носите ли Вы брекеты или не):

if (cond) {
    doIt();
}

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

Как упомянуто, это не короче или более ясно, чем 1 строка если оператор. Однако это не также больше - и не является действительно этим трудно к grok. Если Вы знаете тернарный оператор, довольно очевидно, что происходит.

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

var2 = inVar1 == 0 ? NULL : v.push_back(inVar1);

То, что тернарный оператор всегда возвращает значение - IMO - не важно. Нет, конечно, никакого требования, чтобы Вы использовали все возвращаемые значения..., в конце концов, присвоение возвращает значение.

Однако я заменил бы его, если оператор, если я натыкался на него с ПУСТЫМ ответвлением.

Но, если это заменило 3 строки если оператор:

if (inVar == 0) {
   v.doThingOne(1);
} else {
   v.doThingTwo(2);
}

с:

invar1 == 0 ? v.doThingOne(1) : v.doThingTwo(2);

Я мог бы оставить его... в зависимости от моего настроения.;)

inVar1 != 0 || v.push_back(inVar1);
inVar2 != 0 || v.push_back(inVar2);

общий шаблон, найденный на языках как Perl.

Большинство подвергших пыткам ternaries (как это для аллитерации?) Я вижу, просто попытки помещения логики, которая действительно принадлежит, если оператор в месте, где, если оператор не принадлежит или не может пойти.

Например:

if (inVar1 != 0)
  v.push_back(inVar1);
if (inVar2 != 0)
  v.push_back(inVar2);

работы, предполагающие, что v.push_back является пустым, но что, если он возвращает значение, которое должно быть передано другой функции? В этом случае это должно было бы выглядеть примерно так:

SomeType st;
if (inVar1 != 0)
  st = v.push_back(inVar1);
else if (inVar2 != 0)
  st = v.push_back(inVar2);
SomeFunc(st);

Но это больше к обзору для такой простой части кода. Мое решение: определите другую функцию.

SomeType GetST(V v, int inVar1, int inVar2){
    if (inVar1 != 0)
      return v.push_back(inVar1);
    if (inVar2 != 0)
      return v.push_back(inVar2);        
}

//elsewhere
SomeFunc(GetST(V v, inVar1, inVar2));

Во всяком случае точка - это: если у Вас есть некоторая логика, это слишком подверглось пыткам для троичного, но загромоздит Ваш код, если это вставляется, если оператор, помещает его где-то в другом месте!

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

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

class foo
{
public:
    foo(std::vector<int> input);
private:
    int* array;
    unsigned int size;
};

foo:foo(std::vector<int> input):size(input.size()), array( (input.size()==0)?
        NULL : new int[input.size])
{
    //code to copy elements and do other start up goes here
}

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

Как litb упомянутый в комментариях, это не допустимый C++. GCC, например, испустит ошибку на этом коде:

error: `(&v)->std::vector<_Tp, _Alloc>::push_back [with _Tp = int, _Alloc =
std::allocator<int>](((const int&)((const int*)(&inVar1))))' has type `void' 
and is not a throw-expression

Однако это может работаться вокруг путем кастинга:

inVar1 == 0 ? (void)0 : v.push_back(inVar1);
inVar2 == 0 ? (void)0 : v.push_back(inVar2);

Но в том, что стоит? И для какой цель?

Это не похоже на использование тернарного оператора, здесь больше кратко, чем оператор "if" в этой ситуации:

inVar1 == 0 ? NULL : v.push_back(inVar1);
if(inVar1 != 0) v.push_back(inVar1);

Компиляторы в эти дни сделают если с такой скоростью, как тернарный оператор.

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

Я голосую за

if ( inVar != 0 )
{
   v.push_back( inVar );
}

почему скобки..., потому что однажды можно хотеть поместить что-то еще там и скобки, предварительно сделаны для Вас. Большинство редакторов в эти дни вставит их так или иначе.

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

Сравните:

printf("%s while executing SQL: %s",
        is_sql_err() ? "Error" : "Warning", sql_msg());

с

if (is_sql_err())
    printf("Error while executing SQL: %s", sql_msg());
else
    printf("Warning while executing SQL: %s", sql_msg());

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

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

Так как тернарный оператор возвращает значение, что Вы не используете его, нечетный код. Использование if намного более ясно в случае как Ваш.

Я думаю, что этого нужно избежать. Вы могли использовать 1 строку если оператор в его месте.

if(inVar1 != 0) v.push_back(inVar1);

Я думаю, что Вы были бы лучше обслужены в выполнении надлежащего если структура. Я даже предпочитаю всегда носить брекеты с моим, если структуры, в конечном счете я должен добавить строки позже к условному выполнению.

if (inVar != 0) {
    v.push_back(inVar);
}

Троичной является хорошая вещь, и я обычно продвигаю, это - использование.

Что Вы делаете здесь однако тусклость, это - доверие. Это короче, да, но это напрасно сложно.

Тернарный оператор предназначен для возвращения значения.

IMO, это не должно видоизменять состояние, и возвращаемое значение должно использоваться.

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

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

!inVar1 ?: v.push_back(inVar1);
!inVar2 ?: v.push_back(inVar2);

... если Вы идете для неясного, который является. GCC позволяет x ?: y вместо x ? x : y. :-)