Операции сравнения


Операции сравнения

Основы программирования
Каждый профессионал когда-то был чайником. Наверняка вам знакомо состояние, когда “не знаешь как начать думать, чтобы до такого додуматься”. Наверняка вы сталкивались с ситуацией, когда вы просто не знаете, с чего начать. Эта книга ориентирована как раз на таких людей, кто хотел бы стать программистом, но совершенно не знает, как начать этот путь. Подробнее.

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

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

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

Я не стал использовать операцию деления, потому что пользователь в качестве делителя может ввести число 0. А на ноль, как известно, делить нельзя. Поэтому программа завершится с ошибкой, и пользователь будет очень недоволен.

Как быть? Напрашивается простое решение — проверить значение второго числа, которое вводит пользователь. И если это число равно нулю, то не выполнять операцию деления.

Как сделать такую проверку программно? Да очень просто — выполнить операцию сравнения. То есть сравнить число с нулём.

В таблице 15.3 приведены операции сравнения, которые допускается использовать в языке Free Pascal.

Таблица 15.3. Операторы сравнения Free Pascal.

Оператор Операция
= Равно
<> Не равно
Больше чем
= Больше или равно
in Входит в

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

как в программе использовать операторы сравнения?

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

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

А теперь попробуем доработать программу из предыдущего урока и добавить в неё операцию целого деления. Добавленный код будет выглядеть так:

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

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

замените оператор = на оператор <>. Посмотрите, что получится, если ввести в качестве второго числа 0. Доработайте программу таким образом, чтобы она правильно работала с выражением

Поэкспериментируйте с другими операторами сравнения.

7.3. Операции сравнения

сравнение целых чисел

if [ «$a» -eq «$b» ]

if [ «$a» -ne «$b» ]

if [ «$a» -gt «$b» ]

больше или равно

if [ «$a» -ge «$b» ]

if [ «$a» -lt «$b» ]

меньше или равно

if [ «$a» -le «$b» ]

меньше или равно (внутри двойных круглых скобок)

больше (внутри двойных круглых скобок)

больше или равно (внутри двойных круглых скобок)

сравнение строк

if [ «$a» = «$b» ]

if [ «$a» == «$b» ]

if [ «$a» != «$b» ]

Этот оператор используется при поиске по шаблону внутри [[ . ]].

меньше, в смысле величины ASCII-кодов

if [[ «$a» if [ «$a» \ » необходимо экранировать внутри [ ].

больше, в смысле величины ASCII-кодов

if [[ «$a» > «$b» ]]

if [ «$a» \> «$b» ]

Обратите внимание! Символ «>» необходимо экранировать внутри [ ].

См. Пример 25-6 относительно применения этого оператора сравнения.

строка «пустая» , т.е. имеет нулевую длину

строка не «пустая» .


Оператор -n требует, чтобы строка была заключена в кавычки внутри квадратных скобок. Как правило, проверка строк, не заключенных в кавычки, оператором ! -z, или просто указание строки без кавычек внутри квадратных скобок (см. Пример 7-6), проходит нормально, однако это небезопасная, с точки зрения отказоустойчивости, практика. Всегда заключайте проверяемую строку в кавычки. [1]

Пример 7-5. Операции сравнения

Пример 7-6. Проверка — является ли строка пустой

Пример 7-7. zmost

построение сложных условий проверки

логическое И (and)

exp1 -a exp2 возвращает true, если оба выражения, и exp1, и exp2 истинны.

логическое ИЛИ (or)

exp1 -o exp2 возвращает true, если хотябы одно из выражений, exp1 или exp2 истинно.

Они похожи на операторы Bash && и ||, употребляемые в двойных квадратных скобках.

Операторы -o и -a употребляются совместно с командой test или внутри одинарных квадратных скобок.

Чтобы увидеть эти операторы в действии, смотрите Пример 8-3 и Пример 25-11.

Операции сравнения

Читайте также:

  1. Активно-пассивные операции, их значение
  2. Активные операции, их значение
  3. Алгоритмы сортировки сравнениями
  4. Арифметические выражения и операции
  5. Арифметические операции
  6. Арифметические операции
  7. Арифметические операции на множестве комплексных чисел
  8. Арифметические операции над двоичными числами
  9. Арифметические операции над комплексными числами
  10. Арифметические операции с двоичными числами
  11. Виды и формы мышления. Основные мыслительные операции
  12. Вольтметры на основе метода сравнения.

Арифметические операции

Обзор операций

Рассмотренные выше константы не имеют имен. Но иногда одну и ту же постоянную (т.е. не меняющуюся в ходе работы программы) величину приходится использовать в тексте программы многократно. Тогда может быть удобно назвать ее именем, чтобы в дальнейшем обращаться к ней по этому имени. Значение же ее будет указываться лишь в одном месте — при ее объявлении, и для его изменения необходимо лишь единственное исправление в тексте программы.

Объявление такой именованной константы пишется так же, как и объявление переменной, но перед ее типом указывается слово const :

Илон Маск рекомендует:  Что такое код hw_api &#62;dstofsrcanchors

const double pi=3.14159

Далее ее можно использовать в выражениях, указывая ее имя, например:

Таким образом, именованная константа выглядит, как переменная, но ее значение нельзя менять в процессе работы программы. Зато ее можно использовать там, где разрешается использовать только константы. В языке С++ в сложных программах, разбитых на модули, употребление именованных констант часто считается предпочтительнее, чем директива #define.

Арифметические операции — бинарные. Перечень арифметических операций и их обозначений:

— — вычитание (либо унарная операция — изменение знака);

/ — деление (для int операндов — с отбрасыванием остатка);

% — остаток от деления целочисленных операндов, со знаком первого операнда (деление по модулю).

Операндами традиционных арифметических операций (+ — * /) могут быть константы, переменные, элементы массивов, любые арифметические выражения.

Порядок выполнения операций:

— выражения в круглых скобках;

— функции (стандартные математические, функции пользователя);

— * / выполняются слева направо;

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

Унарные операции + и – обладают самым высоким приоритетом, определены только для целых и вещественных операндов, «+» носит только информационный характер, «–» меняет знак значения операнда на противоположный (не адресная операция).

Таким образом, так как операции *, /, % обладают высшим приоритетом над операциями +, -, при записи сложных выражений нужно использовать общеприня­тые математические правила:

== — равно или эквивалентно;

>= — больше либо равно.

Пары символов соответствующих операций разделять нельзя.

Общий вид операций отношений:

— операндами могут быть любые базовые (скалярные) типы;

— значения операндов перед сравнением преобразуются к одному типу;

— результат операции отношения — целое значение 1, если отношение истинно, или 0 в противном случае. Следовательно, операция отношения может использоваться в любых арифметических выражениях.

| следующая лекция ==>
Строковые константы | Сокращенная запись операции присваивания

Дата добавления: 2014-01-05 ; Просмотров: 157 ; Нарушение авторских прав? ;

Нам важно ваше мнение! Был ли полезен опубликованный материал? Да | Нет

Операции в языке Си

Над объектами в языке Си могут выполняться различные операции:


  • операции присваивания;
  • операции отношения;
  • арифметические;
  • логические;
  • сдвиговые операции.

Результатом выполнения операции является число.

Операции могут быть бинарными или унарными.
Бинарные операции выполняются над двумя объектами, унарные — над одним.

Операция присваивания

Операция присваивания обозначается символом = и выполняется в 2 этапа:

  • вычисляется выражение в правой части;
  • результат присваивается операнду, стоящему в левой части:

объект = выражение;

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

Операции отношения

Основные операции отношения:

  • == эквивалентно — проверка на равенство;
  • != не равно — проверка на неравенство;
  • меньше;
  • > больше;
  • меньше или равно;
  • >= больше или равно.

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

Арифметические операции

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

  • * — умножение;
  • / — деление;
  • + — сложение;
  • — вычитание;
  • % — остаток от целочисленного деления.

Основные унарные операции:

  • ++ — инкрементирование (увеличение на 1);
  • –– — декрементирование (уменьшение на 1);
  • — изменение знака.

Результат вычисления выражения, содержащего операции инкрементирования или декрементирования, зависит от того, где расположен знак операции (до объекта или после него). Если операция расположена до объекта, то сначала происходит изменение значения переменной на 1, а потом это значение используется для выполнения следующих операций. Если операция ++ или расположена после переменной, то сначала выполняется операция, а потом значение переменной изменяется на 1.

Бинарные арифметические операции могут быть объединены с операцией присваивания:

  • объект *= выражение; // объект = объект * выражение
  • объект /= выражение; // объект = объект / выражение
  • объект += выражение; // объект = объект + выражение
  • объект -= выражение; // объект = объект — выражение
  • объект %= выражение; // объект = объект % выражение

Логические операции

Логические операции делятся на две группы:

Условные логические операции чаще всего используются в операциях проверки условия if и могут выполняться над любыми объектами. Результат условной логической операции:

  • 1 если выражение истинно;
  • 0 если выражение ложно.

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

Основные условные логические операции:

  • && — И (бинарная) — требуется одновременное выполнение всех операций отношения;
  • || — ИЛИ (бинарная) — требуется выполнение хотя бы одной операции отношения;
  • ! — НЕ (унарная) — требуется невыполнение операции отношения.

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

Основные побитовые логические операции в языке Си:

инверсия (логическое НЕ) — унарная операция, результат которой равен 0 если операнд единичный, и равен 1, если операнд нулевой;

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

    a

    a b a & b a | b a ^ b
    1
    1 1 1 1
    1 1 1
    1 1 1 1

    a; // e = 241 = 1111 0001
    f = a ^ b; // f = 7 = 0000 0111

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

    Бит Маска
    0x01
    1 0x02
    2 0x04
    3 0x08
    4 0x10
    5 0x20
    6 0x40
    7 0x80


    Для установки определенного бита необходимо соответствующий бит маски установить в 1 и произвести операцию побитового логического ИЛИ с константой, представляющей собой маску:

    Для сброса определенного бита необходимо соответствующий бит маски сбросить в 0 и произвести операцию побитового логического И с константой, представляющей собой инверсную маску:

    0x02); // a = 1, бит 1 сброшен

    Бинарные побитовые логические операции могут быть объединены с операцией присваивания:

    • объект &= выражение; // объект = объект & выражение
    • объект |= выражение; // объект = объект | выражение
    • объект ^= выражение; // объект = объект ^ выражение

    Сдвиговые операции

    Операции арифметического сдвига применяются в целочисленной арифметике и обозначаются как:

    • >> — сдвиг вправо;
    • — сдвиг влево.

    Общий синтаксис осуществления операции сдвига:
    объект = выражение сдвиг КоличествоРазрядов;

    Арифметический сдвиг целого числа вправо >> на 1 разряд соответствует делению числа на 2.
    Арифметический сдвиг целого числа влево на 1 разряд соответствует умножению числа на 2.

    Python 3: Операции

    В Python существуют следующие типы операций:

    В этой статье все примеры будет проверять в интерпретаторе командной строки python3 , который вы можете установить в Debian с помощью команды sudo apt — get install python3 .

    Арифметические операции

    Операции сложения + , вычитания — , умножения * и деления / работают вполне ожидаемо.

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

    В самом синтаксисе языка Python существует операция возведения в степень ** :

    Операции сравнения

    Отдельный набор операций представляет условные выражения. Такие операции возвращают логическое значение, то есть значение типа bool : true , если выражение истинно, и false , если выражение ложно. К подобным операциям относятся операции сравнения и логические операции.

    Операции сравнения

    В операциях сравнения сравниваются два операнда и возвращается значение типа bool — true , если выражение верно, и false , если выражение неверно.

    Сравнивает два операнда на равенство. Если они равны, то операция возвращает true , если не равны, то возвращается false :

    Сравнивает два операнда и возвращает true, если операнды не равны, и false, если они равны.

    Операция «меньше чем». Возвращает true, если первый операнд меньше второго, и false, если первый операнд больше второго:

    Операция «больше чем». Сравнивает два операнда и возвращает true, если первый операнд больше второго, иначе возвращает false:

    Операция «меньше или равно». Сравнивает два операнда и возвращает true, если первый операнд меньше или равен второму. Иначе возвращает false.

    Операция «больше или равно». Сравнивает два операнда и возвращает true, если первый операнд больше или равен второму, иначе возвращается false:

    Операции = имеют больший приоритет, чем == и !=.

    Логические операции

    Также в C# определены логические операторы, которые также возвращают значение типа bool . В качестве операндов они принимают значения типа bool . Как правило, применяются к отношениям и объединяют несколько операций сравнения.

    Операция логического сложения или логическое ИЛИ. Возвращает true, если хотя бы один из операндов возвращает true.

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

    Операция логического сложения. Возвращает true, если хотя бы один из операндов возвращает true.

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

    Операция логического отрицания. Производится над одним операндом и возвращает true, если операнд равен false. Если операнд равен true, то операция возвращает false:

    Операция исключающего ИЛИ. Возвращает true, если либо первый, либо второй операнд (но не одновременно) равны true, иначе возвращает false

    Здесь у нас две пары операций | и || (а также & и && ) выполняют похожие действия, однако же они не равнозначны.

    В выражении z=x|y; будут вычисляться оба значения — x и y.

    В выражении же z=x||y; сначала будет вычисляться значение x, и если оно равно true , то вычисление значения y уже смысла не имеет, так как у нас в любом случае уже z будет равно true . Значение y будет вычисляться только в том случае, если x равно false

    То же самое касается пары операций &/&& . В выражении z=x&y; будут вычисляться оба значения — x и y.

    В выражении же z=x&&y; сначала будет вычисляться значение x, и если оно равно false , то вычисление значения y уже смысла не имеет, так как у нас в любом случае уже z будет равно false . Значение y будет вычисляться только в том случае, если x равно true

    Поэтому операции || и && более удобны в вычислениях, так как позволяют сократить время на вычисление значения выражения, и тем самым повышают производительность. А операции | и & больше подходят для выполнения поразрядных операций над числами.

    Операции со строковыми типами

    Visual Basic позволяет использовать знак операции «+» или «&» для объединения двух строковых операндов (см. табл. 2.5). Результатом операции s+т (или S&T), где Бит имеют строковый тип, будет конкатенация бит — новая строка, результат добавления строки т в конец строки S.


    Стандартные функции для работы со строками. Для работы с переменными строкового типа определены стандартные функции. Некоторые из них (наиболее часто используемые) приведены в табл. 2.6.

    Рассмотрим примеры использования строковых функций.

    1. Выделение первого слова в предложении (разделитель слов — знак «пробел»):

    2. Удаление из строки всех цифр:

    3. Подсчет количества букв ‘W’ в строке (независимо от регистра):

    Операции сравнения

    В результате выполнения операций сравнения получается значение логического типа: true или false. В табл. 2.7 приводятся значения результатов для каждой операции, выполняемой над (01) и (02), в зависимости от значений операндов. Если хотя бы один из операндов при выполнении любой операции принимает значение null, то результатом выполнения операции тоже будет null.

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

    Таблица 2.7. Операнды и результаты операций сравнения

    4.3. Операции сравнения и логические операции

    4.3. Операции сравнения и логические операции

    Меньше либо равно

    больше либо равно

    Примечание. Все операции в результате дают значение типа bool

    Операции сравнения и логические операции в результате дают значение типа bool, то есть true или false. Если же такое выражение встречается в контексте, требующем целого значения, true преобразуется в 1, а false – в 0. Вот фрагмент кода, подсчитывающего количество элементов вектора, меньших некоторого заданного значения:

    vectorint::iterator iter = ivec.beg-in() ;

    while ( iter != ivec.end() ) <

    // эквивалентно: e1em_cnt = e1em_cnt + (*iter some_va1ue)

    // значение true/false выражения *iter some_va1ue

    // превращается в 1 или 0

    e1em_cnt += *iter some_va1ue;

    Мы просто прибавляем результат операции “меньше” к счетчику. (Пара += обозначает составной оператор присваивания, который складывает операнд, стоящий слева, и операнд, стоящий справа. То же самое можно записать более компактно: elem_count = elem_count + n. Мы рассмотрим такие операторы в разделе 4.4.)

    Логическое И () возвращает истину только тогда, когда истинны оба операнда. Логическое ИЛИ (||) дает истину, если истинен хотя бы один из операндов. Гарантируется, что операнды вычисляются слева направо и вычисление заканчивается, как только результирующее значение становится известно. Что это значит? Пусть даны два выражения:

    Если в первом из них expr1 равно false, значение всего выражения тоже будет равным false вне зависимости от значения expr2, которое даже не будет вычисляться. Во втором выражении expr2 не оценивается, если expr1 равно true, поскольку значение всего выражения равно true вне зависимости от expr2.

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

    notFound( ia[ ptr-va1ue ] ))

    Указатель с нулевым значением не указывает ни на какой объект, поэтому применение к нулевому указателю операции доступа к члену вызвало бы ошибку (ptr-value). Однако, если ptr равен 0, проверка на первом шаге прекращает дальнейшее вычисление подвыражений. Аналогично на втором и третьем шагах проверяется попадание величины ptr-value в нужный диапазон, и операция взятия индекса не применяется к массиву ia, если этот индекс неправилен.

    Операция логического НЕ дает true, если ее единственный оператор равен false, и наоборот. Например:

    bool found = false;

    // пока элемент не найден

    // и ptr указывает на объект (не 0)

    while ( ! found ptr ) <

    found = 1ookup( *ptr );

    дает true, если переменная found равна false. Это более компактная запись для

    эквивалентно более длинной записи

    if ( found == true )

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

    // Внимание! Порядок вычислений не определен!

    if ( ia[ index++ ] ia[ index ] )

    // поменять местами элементы

    Программист предполагал, что левый операнд оценивается первым и сравниваться будут элементы ia[0] и ia[1]. Однако компилятор не гарантирует вычислений слева направо, и в таком случае элемент ia[0] может быть сравнен сам с собой. Гораздо лучше написать более понятный и машинно-независимый код:

    if ( ia[ index ] ia[ index+1 ] )

    // поменять местами элементы

    Еще один пример возможной ошибки. Мы хотели убедиться, что все три величины ival, jval и kval различаются. Где мы промахнулись?

    // Внимание! это не сравнение 3 переменных друг с другом

    if ( ival != jva1 != kva1 )


    Значения 0, 1 и 0 дают в результате вычисления такого выражения true. Почему? Сначала проверяется ival != jval, а потом итог этой проверки (true/false – преобразованной к 1/0) сравнивается с kval. Мы должны были явно написать:

    if ( ival != jva1 ival != kva1 jva1 != kva1 )

    Найдите неправильные или непереносимые выражения, поясните. Как их можно изменить? (Заметим, что типы объектов не играют роли в данных примерах.)

    (e) vec[ iva1++ ] = vec[ ival ];

    (b) ival != jva1 kva1 (d) iva1++ ival

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

    Операции сравнения

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

    == – равно или эквивалентно; != – не равно;

    – больше; >= – больше либо равно.

    Пары символов соответствующих операций разделять нельзя.

    Общий вид операций отношений:

    Операнд_1 Знак операции Операнд_2

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

    Значения арифметических выражений перед сравнением вычисляются и преобразуются к одному типу.

    Арифметические операнды преобразуются по правилам, аналогичным для арифметических операций. Операнды-указатели преобразуются в целые числа необходимого типа. Результат сравнения указателей будет корректным в арифметическом смысле лишь для объектов одного массива.

    В языке Си нет логического типа данных. Результат операции отношения имеет значение 1, если отношение истинно, или в результате вычислений получено не нулевое значение, воспринимаемое компилятором Си как истина (true), или – в противном случае, т.е. – ложно (false). Следовательно, операция отношения может использоваться в любых арифметических выражениях.

    Операции сравнения на равенство и неравенство имеют меньший приоритет, чем остальные операции отношений.

    Примеры использования операций отношений:

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

    Дата добавления: 2014-12-30 ; просмотров: 551 ; ЗАКАЗАТЬ НАПИСАНИЕ РАБОТЫ

    Логические выражения в C++ — урок 5

    Всем привет! Сейчас пойдет о логических операторах в C++. Поскольку нам постоянно надо что-то сравнивать (например что больше, а что меньше), то нам надо иметь возможность реализовывать подобный функционал и в C++.

    Логические переменные

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

    • Логические данные хранятся в переменных типа bool.
    • Хранить они могут только два значения:
      • «Верно» — это true ;
      • «Лож» — это false ;

    Теперь давайте узнаем какие логические операторы существуют в C++.

    Операторы сравнения

    Язык C++ имеет 5 различных операторов сравнения в своем арсенале. Также существуют такие операторы, которые являются комбинациями других. Все они вам должны быть знакомы из курса математики, поэтому их изучение не должно вызвать у вас проблем.

    Давайте разберем по порядку каждый из них:

    • A B — возвращает true, если A строго больше B.
    • A == B — проверяет на равенство переменные A и B.
    • A != B — проверяет переменные A и B на неравенство.
    • A >= B — нестрогое неравенство. Возвращает true, если A больше или равно B.
    • A B.

    Теперь давайте разберем пару примеров, тем самым подкрепим теорию практикой:

    Из примера видно, что в качестве A и B мы можем использовать не только переменные, но и простые числа.

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

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

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

    Давайте рассмотрим следующий список:

    • A && B — эквивалент «И». Соответственно возвращает true, если A и B являются истиной.
    • A || B — эквивалент логического «ИЛИ». Вернет true ели хотя бы одно из выражений является истинным.
    • A xor B — этот оператор можно сравнить с «ТОЛЬКО ОДИН», соответственно вернет true если A == true и B == false, или наоборот.
    • !A — данный оператор инвертирует значение A. То есть, если A == true, то он вернет false и наоборот.

    Здесь самая главная «причуда» логических операторов — это их обозначения в C++. В остальном они интуитивно понятны.

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

    она отвечает за форматный вывод bool переменных (вывод слов вместо чисел). Дело в том, что по умолчанию C++ при выводе логических значений используются два значения:

    Таким образом мы «приукрасим» вывод нашей программы и сделаем его более читабельным.

    Илон Маск рекомендует:  Кодировка документа
    Понравилась статья? Поделиться с друзьями:
    Кодинг, CSS и SQL