Тернарный оператор в си: Тернарный оператор и оператор запятая

Использование условного оператора в C++

1. Использование условного оператора в качестве выражения rvalue в C++
2. Использование условного оператора в качестве выражения lvalue в C++

В этой статье объясняется, как использовать условный оператор C++.

Использование условного оператора в качестве выражения

rvalue в C++

Помимо общих арифметических, логических операторов и операторов присваивания, C++ предоставляет несколько специальных операторов, один из которых является условным тернарным оператором. Тернарный означает, что оператор принимает три операнда. Он называется условным оператором, потому что работает аналогично оператору if-else. Оператор имеет вид E1 ? E2 : E3, где первый операнд можно рассматривать как условиеif, которое оценивается и преобразуется в значениеbool.

Если значение bool равно true, вычисляется следующее выражение (E2), и имеют место его побочные эффекты. В противном случае оценивается третье выражение (E3) с учетом его побочных эффектов. Обратите внимание, что мы можем использовать этот оператор как выражение rvalue для условного присвоения значения переменной. В следующем примере кода мы читаем целое число из пользовательского ввода и оцениваем выражение сравнения

input > 10, представляющее операнд E1 в условном операторе. Переменной n присваивается значение input только тогда, когда E1 истинно.

#include <string>
#include <iostream>
using std::cout; using std::endl;
using std::string; using std::cin;
int main() {
    int input;
    cout << "Enter a single integer: ";
    cin >> input;
    int n = input > 10 ? input : 10;
    cout << "n = " << n << endl;
    return EXIT_SUCCESS;
}

Выход:

Enter a single integer: 21
n = 21

Использование условного оператора в качестве выражения

lvalue в C++

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

Обратите внимание, что мы указываем имена переменных только как второй и третий операнды. Тем не менее, как правило, вы можете указывать такие выражения, как cout, у которого есть внешние побочные эффекты; эти эффекты выполняются как обычно.

#include <string>
#include <iostream>
using std::cout; using std::endl;
using std::string; using std::cin;
int main() {
    int input;
    cout << "Enter a single integer: ";
    cin >> input;
    int n = input > 10 ? input : 10;
    cout << "n = " << n << endl;
    int m = 30;
    (n == m ? n : m) = (m * 10) + 2;
    cout << "m = " << m << endl;
    return EXIT_SUCCESS;
}

Выход:

Enter a single integer: 21
n = 21
m = 302

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

MyClass, подобной узлу в односвязном списке. В этом случае мы указываем вызов конструктора в качестве второго операнда, вызываемого с аргументом next, и продолжаем стек рекурсивных вызовов до тех пор, пока node.next не примет значение false. Последнее возможно только в том случае, если указатель node.next имеет значение nullptr.

#include <string>
#include <iostream>
struct MyClass {
    MyClass* next;
    int data;
    MyClass(const MyClass& node)
            : next(node.next ? new MyClass(*node.next) : nullptr), data(node.data) {}
    MyClass(int d) : next(nullptr), data(d) {}
    ~MyClass() { delete next ; }
};
int main() {
    return EXIT_SUCCESS;
}

java — Вложенный тернарный оператор

Вопрос задан

4 года 2 месяца назад

Изменён 2 месяца назад

Просмотрен 5k раз

Прохожу тест-задачу:

С помощью тернарного оператора замените инициализацию переменной b в указанном коде:

int a = 10;
    int b;
    if (a > 0) {
        if (a < 100) {
            b = 1;
        } else {
            b = 0;
        }
    } else {
        b = -1;
    }

По-моему, тут надо использовать вложеный тернарный оператор, я сделал так:

int a = 10;
    int b;
    b = (a > 0) ? ((a < 100) ? b = 1 : b = 0) : b = -1  ;

но тест отвечает, что я не прав. Где я ошибаюсь и почему это так?

• java
• тернарный-оператор

2

Да, вложенная тернарная операция. Логически сделал верно. Но допущена синтаксическая ошибка — попытка присвоить значение переменной b внутри тернарной операции.

Правильно должно быть так:

int a = 10;
int b = a > 0 ? a < 100 ? 1 : 0 : -1;

Вложенное выражение a < 100 ? 1 : 0 возвращает значение, которое используется в выражении выше a > 0 ? ВЛОЖЕННОЕ : -1, которое так же возвращает значение, но уже непосредственно в переменную b.

1

точку с запятой нужно убрать, тогда тренажёр съедает задание 🙂 (тоже самое сейчас прохожу)

2

Зарегистрируйтесь или войдите

Регистрация через Google

Регистрация через Facebook

Регистрация через почту

Отправить без регистрации

Почта

Необходима, но никому не показывается

Отправить без регистрации

Почта

Необходима, но никому не показывается

Нажимая на кнопку «Отправить ответ», вы соглашаетесь с нашими пользовательским соглашением, политикой конфиденциальности и политикой о куки

Условия и циклы | Документация Kotlin

Если выражение

В Kotlin , если является выражением: оно возвращает значение. Следовательно, нет тернарного оператора ( condition ? then : else ), потому что обычный if отлично работает в этой роли.

вар макс = а если (а < b) max = b // С другим вар макс: Целое если (а > б) { макс = а } еще { макс = б } // Как выражение val max = if (a > b) a else b

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

val max = if (a > b) { print(«Выберите») а } еще { print(«Выберите б») б }

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

Когда выражение

когда определяет условное выражение с несколькими ветвями. Он похож на 9Оператор 0005 switch в C-подобных языках. Его простая форма выглядит так.

когда (х) { 1 -> печать («х == 1») 2 -> печать («х == 2») иначе -> { print(«x не 1 и не 2») } }

, когда последовательно сопоставляет свой аргумент со всеми ветвями, пока не будет выполнено какое-либо условие ветвления.

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

Ветвь else оценивается, если ни одно из других условий ветвления не выполняется.

Если , когда используется как выражение , ветвь else является обязательной, если только компилятор не может доказать, что все возможные случаи покрываются условиями ветвления, например, с enum записями класса и запечатанным подвиды классов).

класс перечисления Бит { НОЛЬ, ОДИН } val numericValue = когда (getRandomBit()) { Бит.НОЛЬ -> 0 Бит.ОДИН -> 1 // ‘else’ не требуется, поскольку охватываются все случаи }

В , когда Заявления , Else БИС их обнуляемые аналоги.

филиалы , когда не охватывают все возможные случаи для этого субъекта.

класс перечисления Цвет { КРАСНЫЙ, ЗЕЛЕНЫЙ, СИНИЙ } когда (получитьцвет()) { Color.RED ->

println(«красный») Color.GREEN -> println («зеленый») Color.BLUE -> println («синий») // ‘else’ не требуется, поскольку охватываются все случаи } когда (получитьцвет()) { Color.RED -> println(«red») // нет ветвей для GREEN и BLUE else -> println(«not red») // требуется ‘else’ }

Чтобы определить общее поведение для нескольких случаев, объедините их условия в одну строку с запятой:

когда (x) { 0, 1 -> печать («х == 0 или х == 1») иначе -> напечатать(«иначе») }

Вы можете использовать произвольные выражения (не только константы) в качестве условий ветвления

when (x) { s.toInt() -> print(«s кодирует x») else -> print(«s не кодирует x») }

Вы также можете проверить значение на в или !в диапазон или набор:

когда (х) { in 1. .10 ->

print(«x находится в диапазоне») in validNumbers -> print(«x действителен») !in 10..20 -> print(«x вне диапазона») иначе -> print(«ничего из вышеперечисленного») }

Другим вариантом является проверка того, что значение равно или !равно определенного типа. Обратите внимание, что благодаря смарт-приведениям вы можете получить доступ к методам и свойствам типа без дополнительных проверок.

fun hasPrefix(x: Any) = when(x) { это строка -> x.startsWith («префикс») иначе -> ложь }

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

when { x.isOdd() -> print(«x нечетно») y.isEven() -> print(«y четно») else -> print(«x+y нечетно») }

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

весело Request. getBody() = когда (val response = executeRequest()) { успех -> response.body это HttpError -> бросить HttpException (response.status) }

Область действия переменной, введенной в , когда тема ограничена телом этого , когда .

Циклы For

Цикл for перебирает все, что предоставляет итератор. Это эквивалентно циклу foreach в таких языках, как C#. Синтаксис для выглядит следующим образом:

для (предмет в коллекции) print(предмет)

Телом для может быть блок.

для (элемент: Int в целых числах) { // … }

Как упоминалось ранее, вместо перебирает все, что предоставляет итератор. Это означает, что это:

Все эти три функции нужно пометить как оператор .

Для перебора диапазона чисел используйте выражение диапазона:

fun main() { // начало выборки для (я в 1. .3) { println(я) } for (i in 6 downTo 0 step 2) { println(я) } //конец выборки }

Цикл по по диапазону или массиву компилируется в цикл на основе индекса, который не создает объект итератора.

Если вы хотите просмотреть массив или список с индексом, вы можете сделать это следующим образом:

fun main() { val array = arrayOf («а», «б», «с») // начало выборки для (я в массиве.индексы) { println (массив [я]) } //конец выборки }

Кроме того, вы можете использовать библиотечную функцию withIndex :

fun main() { val array = arrayOf («а», «б», «с») // начало выборки for ((индекс, значение) в array.withIndex()) { println(«элемент $index равен $value») } //конец выборки }

Циклы While

while и циклы do-while выполняют свое тело непрерывно, пока выполняются их условия. Разница между ними заключается во времени проверки условия:

• , а проверяет условие и, если оно выполнено, выполняет тело, а затем возвращается к проверке условия.

• do-while выполняет тело, а затем проверяет условие. Если он удовлетворен, цикл повторяется. Итак, тело do-while выполняется хотя бы один раз независимо от условия.

пока (х > 0) { Икс— } делать { значение у = получитьДанные() } while (y != null) // здесь виден y!

Break and continue в циклах

Kotlin поддерживает традиционные break и continue операторов в циклах. См. Возвраты и прыжки.

Последнее изменение: 09 февраля 2023 г.

Проверка типов и приведение типов Возвраты и переходы

Что такое ? код!? Узнайте о тернарном операторе!

Вы сталкивались со знаком «?» в вашем коде, и вы задаетесь вопросом: «Что это?»

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

Тернарные операторы

По сути, тернарный оператор похож на сокращенный оператор if else.

Они могут быть очень удобны в использовании. Это делает код лаконичным и легко читаемым в нужной ситуации.

оператор if else

Итак, давайте углубимся. Что это? Что ж, подумайте о традиционном операторе if else.

В традиционном операторе if else у нас есть условие. Если это условие истинно, код выполняет одно действие. Если это условие не выполняется, код выполняет что-то еще. Что ж, в случае с тернарным оператором это та же сделка, только отформатированная по-другому, и все в одной строке. Итак, с тройкой вы говорите: «Эй, каково состояние?». Возможно, A больше, чем B, или A в пять раз больше B. Что бы это ни было, вы собираетесь указать переменную, за которой следует вопросительный знак, за которым следуют два значения, разделенные двоеточием.

Давайте рассмотрим несколько конкретных примеров.

КОД

Хорошо, давайте обсудим этот код, который у нас есть.

По сути, у меня есть пин-код, который я определил, пин-код номер шесть. У меня есть тип long, который я определил под названием input. И затем у меня есть переменная, которая является булевой, так что она может быть либо истинной, либо ложной; высокий или низкий. Я назвал это состояние и сказал, что оно равно низкому начальному уровню. Затем в настройке мы инициализируем последовательную связь и устанавливаем режим этого вывода светодиода в качестве выхода. Внизу в цикле на строке 21 мы проверяем чтобы увидеть, есть ли доступный ввод в последовательном буфере. Используя последовательный монитор, мы можем видеть, что если мы введем значение, скажем, 12, и я нажму «Отправить», это значение будет отправлено в последовательный буфер, и доступный последовательный порт вернет количество байтов, которые находятся в буфере. Поэтому, если в буфере нет байтов, он возвращается к нулю или false. И поэтому, пока оно ложно, оператор if else не будет выполняться, но если он истинен, то выполняется оператор if. И если утверждение истинно и что-то доступно, мы используем функцию parseInt. Он будет искать в последовательном буфере первое целое число, а затем вернет это значение как длинное. А потом мы просто распечатываем это.

Сокращение оператора if else

Итак, здесь у нас есть наш стандартный оператор if else.

И у нас есть условие в этом операторе if. Он говорит: эй, ввод больше 100? Если это так, то установите состояние равным высокому. В противном случае, если оно не больше 100, мы установим состояние равным низкому. Затем в этой последней строке мы просто пишем цифровую запись на этот вывод светодиода. Так что это будет либо наш максимум, либо минимум. Если вход больше 100, он будет высоким. Если меньше 100, то мало. Таким образом, светодиод будет либо гореть, либо выключаться в зависимости от того, что мы вводим в последовательный монитор.