Логические операции не, и, или (!, &&, ||)

Операнды этих логических операций рассматриваются как имеющие значение ЛОЖЬ, если они равны нулю, и значение ИСТИНА – если не равны нулю. Результатом любой логической операции является значение логического типа ИСТИНА или ЛОЖЬ.

Результат унарной операции логическое НЕ (!) есть ЛОЖЬ, если операнд имеет значение ИСТИНА, и ИСТИНА, – если операнд имеет значение ЛОЖЬ.

Результат операции логическое И (&&) имеет значение ИСТИНА, только если оба операнда имеют значение ИСТИНА.

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

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

int a = 5, b = 10, c;

с = a + b; //с = 15

с = !(a + b); //с = 0

с = a && b; //с = 1

с = a - 5 && b; //с = 0

с = (a && b) - 5; //с = -4

с = a >= 10 && b >= 10; //с = 0

с = !(a >= 10 && b >= 10); //с = 1

с = a >= 10 || b >= 10; // с = 1

с = !a >= 10 || !b >= 10; //с = 0

с = ( . . . ) || 1; //с всегда равно 1

с = ( . . . ) && 0; //с всегда равно 0

Условная операция (?:)

Эта операция тернарная, т.е. имеет 3 операнда. Ее формат:

операнд1 ? операнд2 : операнд3

Первый операнд всегда рассматривается с точки зрения его логического значения, и если результат вычисления первого операнда есть ИСТИНА, то результатом условной операции будет значение второго операнда, иначе – третьего операнда. Вычисляется всегда либо второй операнд, либо третий. Примеры:

int a = 5, b = 10, max;

max = (b > a) ? b : a; //max = 10

a = (a < b) ? a + 1 : 5; //при повторе а будет изменяться в диапазоне от 5 до 10

a = a / b ? 5 : a + 1; //при повторе а будет изменяться в диапазоне от 5 до 10

Условная операция правоассоциативна, т.е. выполняется справа налево. Например, выражение a ? b : c ? d : e вычисляется как a ? b : (c ? d : e).

Операция запятая (,)

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

int a, b, c;

c = 2 * (a = 3, b = 7, a + 2) + b; //c = 17

c = a + b; //c = 10

Тот же результат можно получить без использования операции запятая:

int a = 3, b = 7, c;

c = 2 * (a + 2) + b;

c = a + b;

Следующие 3 оператора: a = 1; b = 2; c = 3; можно объединить в один: a = 1, b = 2, c = 3;

Операции взятия адреса и разадресации

Унарная операция взятия адреса (&) позволяет получить адрес операнда, хранящего свое значение в оперативной памяти (точнее, адрес первого байта, если под значение отводится несколько байт). Объект, предназначенный для хранения адреса операнда, называется указателем и описывается по аналогии с описанием переменной с тем лишь отличием, что перед именем указателя ставится звездочка (*). Например:

int a = 5, b = 10, c; //описание переменных a, b, c и инициализация a и b

int *pa, *pb; //описание указателей pa и pb, которые пока ни на что не указывают

pa = &a; //указатель pa теперь будет указывать на переменную а

pb = &b; //указатель pb теперь будет указывать на переменную b

Последние 3 строки можно записать короче:

int *pa = &a, *pb = &b; //описание и инициализация указателей pa и pb

Унарная операция разадресации (*) позволяет получить значение операнда по значению указателя на этот операнд:

c = *pa; //c = 5

c = *pb; //c = 10

c = *pa + *pb; //c = 15

pb = pa;

c = *pb; //c = 5

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

pa = 0; //указателей pa теперь ни на что не указывает

pb = NULL; //указателей pb теперь ни на что не указывает

c = *pa; //ошибка

c = *pb; //ошибка

Оставшиеся 4 унарные операции (строка 1), будут рассмотрены позднее. Отметим лишь следующее:

Операция () обозначает вызов функции (например main(), printf(…), scanf(…) и др.).

Операция [] обеспечивает доступ к элементам массива.

Операции . (точка) и -> обеспечивают доступ к полям структуры.