bulgakov

14. Составные условия: и, или, не

В предыдущем уроке if выбирал действие по одной проверке. Но число может одновременно быть не меньше 10 и не больше 20. А чтобы оказаться вне промежутка от 5 до 10, достаточно быть меньше 5 или больше 10. Для таких условий в C есть логические операторы.

И: должны выполниться обе проверки

&& читается как «и». Выражение x >= 10 && x <= 20 проверяет, что x находится в промежутке от 10 до 20 включительно. Сначала получаются результаты сравнений, затем из них — один общий результат.

Полная программа:

C
#include <stdio.h>

int main(void)
{
    int x = 15;
    int inside = x >= 10 && x <= 20;

    printf("Inside [10, 20]: %d\n", inside);
    if (inside) {
        printf("Both comparisons are true\n");
    }
    return 0;
}

Вывод:

Inside [10, 20]: 1
Both comparisons are true

При x = 15 сравнения 15 >= 10 и 15 <= 20 дают 1. Поэтому && тоже даёт 1, это значение сохраняется в inside, а if выполняет свой блок. При x = 25 левая проверка верна, но правая — нет: общий результат будет 0, и второй строки вывода не будет.

Таблица истинности показывает все сочетания двух проверок. Здесь 0 означает ложь, 1 — истину:

Левая проверка Правая проверка Результат &&
0 0 0
0 1 0
1 0 0
1 1 1

Логические операторы дают int со значением ровно 0 или 1. Их исходные значения не обязаны быть единицами: любое ненулевое значение считается истинным. Например, 3 && -2 даёт 1, а 3 && 0 — 0.

Или: достаточно одной верной проверки

|| читается как «или». Для выхода из промежутка [5, 10] есть две возможности: число меньше 5 или больше 10. Числа 5 и 10 входят в промежуток, поэтому в проверке выхода нужны строгие сравнения < и >.

Полная программа:

C
#include <stdio.h>

int main(void)
{
    int x = 12;
    int outside = x < 5 || x > 10;

    printf("Outside [5, 10]: %d\n", outside);
    if (outside) {
        printf("At least one comparison is true\n");
    }
    return 0;
}

Вывод:

Outside [5, 10]: 1
At least one comparison is true

Проверка 12 < 5 даёт 0, а 12 > 10 — 1. Одной истины достаточно, поэтому общий результат — 1.

Левая проверка Правая проверка Результат ||
0 0 0
0 1 1
1 0 1
1 1 1

В логическом «или» допускается, что верны обе проверки. Например, x > 0 || x % 2 == 0 истинно для x = 4: число и положительное, и чётное. Оба свойства верны, но для получения результата || достаточно первой истины: второе сравнение при выполнении уже пропускается. Ниже разберём этот порядок подробнее.

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

x x >= 10 && x <= 20 x < 5 || x > 10
4 0 1
5 0 0
10 1 0
11 1 1
20 1 1
21 0 1

Последние два столбца относятся к разным промежуткам. Например, 11 входит в [10, 20], но находится вне [5, 10].

Не: поменять истинность на противоположную

! применяется к одному выражению. Если оно равно нулю, ! даёт 1; если не равно нулю — 0. Это логическое отрицание, а не смена знака числа.

Полная программа:

C
#include <stdio.h>

int main(void)
{
    int x = 0;
    int y = 10;

    printf("!x: %d\n", !x);
    printf("!y: %d\n", !y);
    printf("-y: %d\n", -y);
    return 0;
}

Вывод:

!x: 1
!y: 0
-y: -10

Ноль у x означает ложь, поэтому !x — истина. Ненулевое значение y означает истину, поэтому !y — ложь. А минус перед y получает отрицательное число, сохраняя его величину.

Чтобы отрицать целую проверку, заключите её в скобки. Для целого x условие !(x >= 0) означает «неверно, что x неотрицателен» и равносильно x < 0. Фрагмент внутри main, где уже объявлен int x и подключён <stdio.h>:

C
if (!(x >= 0)) {
    printf("Negative\n");
}

При x = -3 сравнение даёт 0, отрицание — 1, и появляется строка Negative. При нуле и положительном числе блок пропускается. Скобки существенны: !x >= 0 сначала вычисляет !x, а оно всегда равно 0 или 1; оба эти числа не меньше нуля.

Как записывать составное условие

Математическую цепочку 10 ≤ x ≤ 20 в C записывают как две проверки, соединённые &&: 10 <= x && x <= 20.

Запись 10 <= x <= 20 не проверяет промежуток. Сначала 10 <= x даёт 0 или 1, затем уже это маленькое число сравнивается с 20. Поэтому даже для x = 30 получится истина: 10 <= 30 даёт 1, а 1 <= 20 тоже даёт 1.

При смешивании операторов полезно показывать группы скобками. Например, (x >= 10 && x <= 20) || x == 100 означает: «число входит в [10, 20] или равно 100». В C && связывает выражения сильнее, чем ||, поэтому здесь скобки не меняют результат, но делают замысел видимым. Сравнения также связываются сильнее, чем && и ||.

Не заменяйте && на &, а || на |: одиночные знаки обозначают другие, побитовые операции и не дают описанного ниже пропуска правой части.

Отрицание составного условия

Пусть x — целое число. Условие x > 0 && x < 10 означает: число находится строго между 0 и 10. Чтобы это условие было ложным, достаточно нарушить хотя бы одну границу: x <= 0 или x >= 10. Поэтому записи !(x > 0 && x < 10) и x <= 0 || x >= 10 дают одинаковый результат.

Это пример закона Де Моргана: при отрицании «и» превращается в «или», а каждая отдельная проверка тоже отрицается. В общем виде для проверок a и b:

  • !(a && b) равносильно !a || !b;
  • !(a || b) равносильно !a && !b.

Например, при x = 5 условие «строго внутри» истинно, а обе формы его отрицания дают 0. При x = 10 проверка x < 10 ложна: обе формы отрицания дают 1. Мы заменили > на <= и < на >=, потому что речь здесь о целых числах, для которых это противоположные проверки.

Почему правая часть иногда не вычисляется

&& и || проверяют левую часть первой. Затем правая вычисляется лишь тогда, когда без неё нельзя получить общий ответ:

  • Для && слева 0 — весь результат уже 0, правую часть можно пропустить.
  • Для || слева ненулевое значение — весь результат уже 1, правую часть можно пропустить.

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

Полная программа читает одно целое число в диапазоне int:

C
#include <stdio.h>

int main(void)
{
    int divisor = 0;

    if (scanf("%d", &divisor) != 1) {
        printf("Input error\n");
        return 1;
    }

    if (divisor != 0 && 120 / divisor > 10) {
        printf("Quotient is greater than 10\n");
    } else {
        printf("Condition is false\n");
    }
    return 0;
}

scanf должна успешно прочитать одно число. Иначе программа выводит ошибку и завершает main через return 1, не переходя к делению.

Ввод Вывод Что произошло
0 Condition is false Первая проверка дала 0; деление не выполнялось
10 Quotient is greater than 10 120 / 10 даёт 12, а 12 > 10 истинно
12 Condition is false 120 / 12 даёт 10; строгое 10 > 10 ложно
-2 Condition is false 120 / -2 даёт -60; оно не больше 10
q Input error Число не прочитано; программа закончилась раньше

Порядок частей здесь важен. Если поставить 120 / divisor > 10 первым, деление случится до проверки нуля.

У || аналогичный пропуск виден в выражении divisor == 0 || 120 / divisor > 10: при нуле левая часть истинна, поэтому деления не будет. Сам смысл этого условия уже другой: «делитель нулевой или частное больше десяти».

Следующий урок — выбор по значению: switch, case и break.

ПрактикаЗагружаем тест…