14. Составные условия: и, или, не
В предыдущем уроке if выбирал действие по одной проверке. Но число может одновременно быть не меньше 10 и не больше 20. А чтобы оказаться вне промежутка от 5 до 10, достаточно быть меньше 5 или больше 10. Для таких условий в C есть логические операторы.
И: должны выполниться обе проверки
&& читается как «и». Выражение x >= 10 && x <= 20 проверяет, что x находится в промежутке от 10 до 20 включительно. Сначала получаются результаты сравнений, затем из них — один общий результат.
Полная программа:
#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 входят в промежуток, поэтому в проверке выхода нужны строгие сравнения < и >.
Полная программа:
#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. Это логическое отрицание, а не смена знака числа.
Полная программа:
#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>:
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:
#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.
