§ 2. Логический тип

В классическом языке С такого типа не было. Вместо него использовался целый тип. Он появился в языке С++. Переменные логического (булевского) типа объявляются например следующим, образом: bool B1, B2, B3, B4. Переменная данного типа может принимать одно из двух значений — true или false, которые являются логическими константами. Кроме этих переменных дальше в тексте будем использовать вещественные переменные x и y, определяющие координаты точки на плоскости в декартовой системе координат.

Переменные такого типа можно использовать в следующих операторах:

• в операторах присваивания, например, B1=x>0; B1=true; B2=y>0 && x<0; B1=B2 || x*x+y*y<=4;

• в операторе if, например, if (B1) …, что равносильно

if (B1= = true) …;

• в операторах while и do … while, например, while (B1) { …}, что равносильно while(B1= = true) {…};

• в заголовке оператора for. Чаще всего булевский тип используется во второй части заголовка. Например, for (x=1; B1; x+=0.5) {…}; что равносильно for (x=1; B1==true; x+=0.5) {…};

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

Для логических переменных и констант определены логические операции &&, || , ! (см. 3.3 ) и операции сравнения (> , < , >=, <=, = =, !=). Например, присваивание B3 = y>x*x && fabs(x)<2 можно записать следующим образом:

B1= y>x*x; B2= fabs(x)<2; B3=B1 && B2.

При сравнении логических величин учитывается, что результаты следующих сравнений истинны: true>false; true = = true; false = = false. Например, пусть B1=x>0; B2=y>0. Выражение B1>B2 истинно тогда и только тогда, когда x>0 && y<=0 истинно, т. е. когда B1==true, а B2==false. Выражение B1 = = B2 истинно тогда и только тогда, когда x>0 && y>0 || x<=0 && y<=0, т. е. когда B1==true и B2==true или обе переменные принимают значение false. Выражение !(B1<B2) равносильно

x>0 && y<=0|| x>0 && y>0 || x<=0 && y<=0.

Существует связь между логическими операциями и оператором if.

Например, присваивание B3=B1 && B2 с помощью if без логических операций можно записать так: if (B1) B3 = B2; else B3 = false.

B3=!B1 || B2 равносильно

if (B2) B3=true;

else if (B1) B3 = false;

else B3 = true.

Мы уже знаем, что целый тип совместим с булевским типом. Любое ненулевое число играет роль true, а нуль равносилен false. Поэтому если int flag, то оператор if (flag) cout<<”Yes”; else cout<<”No”; равносилен следующему:

if (flag!=0) cout<<”Yes”; else cout<<”No”. Этим можно объяснить отсутствие такого типа в старом языке C.

Следует различать логические операции и битовые.

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

int b1=10<0xA, b2=0x10, b3; b3=b1 || b2 && 10; cout<<b3;

получим единицу. Почему? Так как 10 и 0xA — одно и то же число в разных системах счисления, то результат сравнения ложный и b1=0. Значением переменной b2 является ненулевое число 16 в шестнадцатеричной системе счисления, и это соответствует истине. Поэтому b2 && 10 даст в результате истину, и b3 как результат логической операции или будет также истинным, несмотря на то, что b1 = 0. Таким образом, будет выведена единица.

Если объявить bool b1=10<0xA, b2=0x10, b3; то результат будет тот же самый, т. е. будет выведена единица (а не true).

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

bool b1=10<0xA, b2=0x10, b3;

b3=b1 | b2 & 10; cout<<b3;

В результате операции b2 & 10 получим 0, потому что битовая операция применяется к каждой паре битов, т. е. 1₂ & 1010₂=0. Значением b1 является false, т. е. 0. Поэтому в результате будет выведен 0. Необходимо обратить внимание, что значением переменной b2 будет 1, а не 10000₂ . По этой же причине, если bool b2=10, то в результате всё равно получим 0.

Но если int b1=10<0xA, b2=10, b3; то получим 10, так как 10&10=10, b1=0, 0 | 10 =10.