Как обозначить не равно в c

Операторы сравнения часто используются в условных выражениях, включая инструкцию if :

let name = "world" if name == "world" < print("hello, world") >else < print("Мне жаль, \(name), но я тебя не узнаю") >// напечатает "hello, world", так как name очевидно равно "world"

Подробнее об инструкции if см. в главе "Управление потоком".

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

(1, "zebra") < (2, "apple") // true, потому что 1 меньше 2, "zebra" и "apple" не сравниваются (3, "apple") < (3, "bird") // true , потому что 3 равно 3, а "apple" меньше чем "bird" (4, "dog") == (4, "dog") // true , потому что 4 равно 4 и "dog" равен "dog"

В примере выше, в первой строке вы можете видеть сравнение слева направо. Так как 1 меньше 2 , то (1, “zebra”) меньше (2, “apple”) , несмотря на остальные значения кортежа, потому что это неравенство было определено первыми членами. Не важно, что “zebra” не меньше, чем “apple” , потому что сравнение уже определено первыми элементами кортежей. Однако, когда первые элементы кортежей одинаковые, то сравниваются вторые элементы и так далее.

Кортежи могут сравниваться, только в том случае, если оператор сравнения можно применить ко всем членам кортежей соответственно. Например, как показано в коде ниже, вы можете сравнить два кортежа типа (String, Int) потому что и String , и Int могут сравниться оператором < . И наоборот, кортеж типа (String, Bool) сравниваться не может, так как к значениям типа Bool операторы сравнения не применяются.

("blue", -1) < ("purple", 1) // OK, расценивается как true ("blue", false) < ("purple", true) // Ошибка так как < не может применяться к значениям типа Bool 

Заметка

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

Тернарный условный оператор

Тернарный условный оператор — это специальный оператор из трех частей, имеющий следующий синтаксис: выражение ? действие1 : действие2 . Он выполняет одно из двух действий в зависимости от того, является ли выражение true или false . Если выражение равно true , оператор выполняет действие1 и возвращает его результат; в противном случае оператор выполняет действие2 и возвращает его результат.

Тернарный условный оператор является краткой записью следующего кода:

if выражение < действие1 >else

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

let contentHeight = 40 let hasHeader = true let rowHeight = contentHeight + (hasHeader ? 50 : 20) // rowHeight равно 90

В развернутом виде этот код можно записать так:

let contentHeight = 40 let hasHeader = true var rowHeight = contentHeight if hasHeader < rowHeight = rowHeight + 50 >else < rowHeight = rowHeight + 20 >// rowHeight равно 90

В первом примере с помощью тернарного условного оператора величине rowHeight в одну строку присваивается правильное значение. Этот вариант не только короче второго примера, но и позволяет объявить величину rowHeight константой, так как в отличие от конструкции if ее значение не нужно изменять.

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

Оператор объединения по nil

Оператор объединения по nil ( a ?? b ) извлекает опционал a , если он содержит значение, или возвращает значение по умолчанию b , если a равно nil . Выражение a может быть только опционалом. Выражение b должно быть такого же типа, что и значение внутри a .

Оператор объединения по nil является краткой записью следующего кода:

a != nil ? a! : b

В вышеприведенном коде тернарный условный оператор и принудительное извлечение ( a! ) используются для обращения к значению внутри a , если a не равно nil , или для возвращения b в противном случае. Оператор объединения по nil — это более элегантный, короткий и понятный способ одновременно проверить условие и извлечь значение.

Заметка

Если a не равно nil , выражение b не анализируется. Такой подход называется краткой проверкой условия (short-circuit evaluation).

В следующем примере оператор объединения по nil выбирает между стандартным значением цвета и пользовательским:

let defaultColorName = "red" var userDefinedColorName: String? // по умолчанию равно nil var colorNameToUse = userDefinedColorName ?? defaultColorName // userDefinedColorName равен nil, поэтому colorNameToUse получит значение по умолчанию — "red"

Переменная userDefinedColorName объявлена как строковый ( String ) опционал и по умолчанию равна nil . Так как userDefinedColorName является опционалом, ее значение можно анализировать посредством оператора объединения по nil . В вышеприведенном примере этот оператор задает начальное значение для строковой ( String ) переменной colorNameToUse . Так как userDefinedColorName равно nil , выражение userDefinedColorName ?? defaultColorName возвратит значение defaultColorName , т. е. "red" .

Если переменной userDefinedColorName присвоить отличное от nil значение и снова передать ее в оператор объединения по nil , вместо значения по умолчанию будет использовано значение внутри userDefinedColorName :

userDefinedColorName = "green" colorNameToUse = userDefinedColorName ?? defaultColorName // userDefinedColorName не равно nil, поэтому colorNameToUse получит значение "green"

Операторы диапазона

В языке Swift есть два оператора диапазона, которые в короткой форме задают диапазон значений.

Оператор замкнутого диапазона

Оператор замкнутого диапазона ( a. b ) задает диапазон от a до b , включая сами a и b . При этом значение a не должно превышать b .

Оператор замкнутого диапазона удобно использовать при последовательном переборе значений из некоторого диапазона, как, например, в цикле for-in :

for index in 1. 5 < print("\(index) умножить на 5 будет \(index * 5)") >// 1 умножить на 5 будет 5 // 2 умножить на 5 будет 10 // 3 умножить на 5 будет 15 // 4 умножить на 5 будет 20 // 5 умножить на 5 будет 25

Подробнее о циклах for-in см. в главе Управление потоком.

Оператор полузамкнутого диапазона

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

let names = ["Anna", "Alex", "Brian", "Jack"] let count = names.count for i in 0.. // Person 1 будет Anna // Person 2 будет Alex // Person 3 будет Brian // Person 4 будет Jack

Односторонние диапазоны

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

for name in names[2. ] < print(name) >// Brian // Jack for name in names[. 2] < print(name) >// Anna // Alex // Brian

Оператор полузамкнутого диапазона так же имеет одностороннюю форму, которая записывается только с одним конечным значением. Точно так же как и в случае, когда вы включаете значение в обе стороны, конечное значение не является частью самого диапазона. Например:

for name in names[.. // Anna // Alex

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

let range = . 5 range.contains(7) // false range.contains(4) // true range.contains(-1) // true

Логические операторы

Логические операторы изменяют или комбинируют логические значения типа Boolean (булево) — true и false . Язык Swift, как и другие C-подобные языки, поддерживает три стандартных логических оператора:

• логическое НЕ ( !a )
• логическое И ( a && b )
• логическое ИЛИ ( a || b )

Оператор логического НЕ

Оператор логического НЕ ( !a ) инвертирует булево значение — true меняется на false , а false становится true .

Оператор логического НЕ является префиксным и ставится непосредственно перед значением, без пробела. Как видно из следующего примера, его можно воспринимать как "не allowedEntry ":

let allowedEntry = false if !allowedEntry < print("ACCESS DENIED") >// Выведет "ACCESS DENIED"

Конструкция if !allowedEntry означает "если не allowedEntry ". Идущая за ней строка будет выполнена, только если "не allowedEntry" является истиной, т. е. если allowedEntry равно false .

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

Оператор логического И

Оператор логического И ( a && b ) дает на выходе true тогда и только тогда, когда оба его операнда также равны true .

Если хотя бы один из них равен false , результатом всего выражения тоже будет false . На самом деле, если первое значение равно false , то второе даже не будет анализироваться, так как оно все равно не изменит общий результат на true . Такой подход называется краткой проверкой условия (short-circuit evaluation).

В следующем примере проверяются два значения типа Bool , и если они оба равны true , программа разрешает доступ:

let enteredDoorCode = true let passedRetinaScan = false if enteredDoorCode && passedRetinaScan < print("Welcome!") >else < print("ACCESS DENIED") >// Выведет "ACCESS DENIED"

Оператор логического ИЛИ

Оператор логического ИЛИ ( a || b ) является инфиксным и записывается в виде двух вертикальных палочек без пробела. С его помощью можно создавать логические выражения, которые будут давать true , если хотя бы один из операндов равен true .

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

В приведенном ниже примере первое значение типа Bool ( hasDoorKey ) равно false , а второе ( knowsOverridePassword ) равно true . Поскольку одно из значений равно true , результат всего выражения тоже становится true и доступ разрешается:

let hasDoorKey = false let knowsOverridePassword = true if hasDoorKey || knowsOverridePassword < print("Welcome!") >else < print("ACCESS DENIED") >// Выведет "Welcome!"

Комбинирование логических операторов

Можно также составлять и более сложные выражения из нескольких логических операторов:

if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword < print("Welcome!") >else < print("ACCESS DENIED") >// Выведет "Welcome!"

В этом примере с помощью нескольких операторов && и || составляется более длинное и сложное выражение. Однако операторы && и || по-прежнему применяются только к двум величинам, поэтому все выражение можно разбить на три простых условия. Алгоритм работы будет следующим:

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

Исходя из значений enteredDoorCode , passedRetinaScan и hasDoorKey первые два подусловия дают false . Однако был введен код экстренного доступа, поэтому все составное выражение по-прежнему равно true .

Заметка

Логические операторы Swift && и || являются лево-ассоциированными, что означает, что составные выражения с логическими операторами оценивают в первую очередь выражения слева направо.

Явное указание круглых скобок

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

if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword < print("Welcome!") >else < print("ACCESS DENIED") >// Выведет "Welcome!"

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

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Урок №43. Логические операторы: И, ИЛИ, НЕ

На этом уроке мы рассмотрим логические операторы И, ИЛИ и НЕ в языке С++.

Оглавление:

1. Логические операторы
2. Логический оператор НЕ
3. Логический оператор ИЛИ
4. Логический оператор И
5. Короткий цикл вычислений
6. Использование логических операторов И/ИЛИ
7. Законы Де Моргана
8. А где же побитовое исключающее ИЛИ (XOR)?
9. Тест

Логические операторы

В то время как операторы сравнения используются для проверки конкретного условия: ложное оно или истинное, они могут проверить только одно условие за определенный промежуток времени. Но бывают ситуации, когда нужно протестировать сразу несколько условий. Например, чтобы узнать, выиграли ли мы в лотерею, нам нужно сравнить все цифры купленного билета с выигрышными. Если в лотерее 6 цифр, то нужно выполнить 6 сравнений, все из которых должны быть true.

Также иногда нам нужно знать, является ли хоть одно из нескольких условий истинным. Например, мы не пойдем сегодня на работу, если больны или слишком устали, или если выиграли в лотерею. �� Нам нужно проверить, является ли хоть одно из этих трех условий истинным. Как это сделать? С помощью логических операторов! Они позволяют проверить сразу несколько условий за раз.

В языке C++ есть 3 логических оператора:

Логический оператор НЕ

Мы уже с ним сталкивались на уроке №34.

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

bool bTooLarge = ( x > 100 ) ; // переменная bTooLarge будет true, если x > 100
if ( ! bTooLarge )
// Делаем что-нибудь с x
// Выводим ошибку

Следует помнить, что логический оператор НЕ имеет очень высокий уровень приоритета. Новички часто совершают следующую ошибку:

std :: cout << "x does not equal y" ; std :: cout << "x equals y" ;

Результат выполнения программы:

Но х ведь не равно у , как это возможно? Поскольку приоритет логического оператора НЕ выше, чем приоритет оператора равенства, то выражение ! х == у обрабатывается как (! х) == у . Так как х — это 5 , то !x — это 0 . Условие 0 == у ложное, поэтому выполняется часть else!

Напоминание: Любое ненулевое целое значение в логическом контексте является true. Так как х = 5 , то х вычисляется как true, а вот !x = false , т.е. 0 . Использование целых чисел в логических операциях подобным образом может запутать не только пользователя, но и самого разработчика, поэтому так не рекомендуется делать!

Правильный способ написания программы, приведенной выше:

if ( ! ( x == y ) )
std :: cout << "x does not equal y" ; std :: cout << "x equals y" ;

Сначала обрабатывается х == у , а затем уже оператор НЕ изменяет результат на противоположный.

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

Логический оператор ИЛИ

Если хоть одно из двух условий является истинным, то логический оператор ИЛИ является true.

Рассмотрим следующую программу:

std :: cout << "Enter a number: " ; std :: cin >> value ;
if ( value == 0 || value == 1 )
std :: cout << "You picked 0 or 1" << std :: endl ; std :: cout << "You did not pick 0 or 1" << std :: endl ;

Здесь мы использовали логический оператор ИЛИ, чтобы проверить, является ли хоть одно из двух условий истинным: левое ( value == 0 ) или правое ( value == 1 ). Если хоть одно из условий — true или оба сразу true, то выполняться будет стейтмент if. Если ни одно из условий не является true, то результат — false и выполняться будет стейтмент else.

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

if ( value == 0 || value == 1 || value == 2 || value == 3 )
std :: cout << "You picked 0, 1, 2, or 3" << std :: endl ;

Новички иногда путают логическое ИЛИ ( || ) с побитовым ИЛИ ( | ). Хоть у них и одинаковые названия, функции они выполняют разные.

Логический оператор И

Только при условии, что оба операнда будут истинными, логический оператор И будет true. Если нет, тогда — false.

Например, мы хотим узнать, находится ли значение переменной х в диапазоне от 10 до 20. Здесь у нас есть два условия: мы должны проверить, является ли х больше 10 и является ли х меньше 20.

std :: cout << "Enter a number: " ; std :: cin >> value ;
if ( value > 10 && value < 20 ) std :: cout << "Your value is between 10 and 20" << std :: endl ; std :: cout << "Your value is not between 10 and 20" << std :: endl ;

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

Как и с логическим ИЛИ, мы можем комбинировать сразу несколько условий И:

if ( value > 10 && value < 20 && value != 16 ) // Делаем что-нибудь // Делаем что-нибудь другое

Короткий цикл вычислений

Для того, чтобы логическое И возвращало true, оба операнда должны быть истинными. Если первый операнд вычисляется как false, то оператор И должен сразу возвращать false независимо от результата второго операнда (даже без его обработки). Это называется коротким циклом вычисления (англ. «short circuit evaluation») и выполняется он, в первую очередь, в целях оптимизации.

Аналогично, если первый операнд логического ИЛИ является true, то и всё условие будет true (даже без обработки второго операнда).

Как и в случае с оператором ИЛИ, новички иногда путают логическое И ( && ) с побитовым И ( & ).

Использование логических операторов И/ИЛИ

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

Многие программисты думают, что логические И и ИЛИ имеют одинаковый приоритет (или забывают, что это не так), так же как и сложение/вычитание или умножение/деление. Тем не менее, приоритет логического И выше приоритета ИЛИ. Таким образом, операции с оператором И всегда будут вычисляться первыми (если только операции с ИЛИ не находятся в круглых скобках).

Рассмотрим следующее выражение: value1 || value2 && value3 . Поскольку приоритет логического И выше, то обрабатываться выражение будет так:

value1 || (value2 && value3)

(value1 || value2) && value3

Хорошей практикой является использование круглых скобок с операциями. Это предотвратит ошибки приоритета, увеличит читабельность кода и чётко даст понять компилятору, как следует обрабатывать выражения. Например, вместо того, чтобы писать value1 && value2 || value3 && value4 , лучше записать (value1 && value2) || (value3 && value4) .

Законы Де Моргана

Многие программисты совершают ошибку, думая, что !(x && y) — это то же самое, что и !x && !y . К сожалению, вы не можете использовать логическое НЕ подобным образом.

Законы Де Моргана гласят, что !(x && y) эквивалентно !x || !y , а !(x || y) эквивалентно !x && !y .

Другими словами, логические операторы И и ИЛИ меняются местами! В некоторых случаях, это даже полезно, так как улучшает читабельность.

А где же побитовое исключающее ИЛИ (XOR)?

Побитовое исключающее ИЛИ (XOR) — это логический оператор, который используется в некоторых языках программирования для проверки на истинность нечётного количества условий.

В языке C++ нет такого оператора. В отличии от логических И/ИЛИ, к XOR не применяется короткий цикл вычислений. Однако его легко можно сымитировать, используя оператор неравенства ( != ):