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

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

varl = (var2 != 0) && (var3 / var2 > 2);

Здесь в случае если var2 равна О деление var3 на var2 будет приводить либо к возникновению ошибки из-за невозможности выполнения деления на ноль, либо к определению переменной varl как содержащей бесконечное значение (которое является допустимым и поддается обнаружению в случае некоторых типов, например, float).

Поразрядные операции

к этому моменту вполне может возникнуть вопрос, а зачем вообще нужны операции & и I ? Все дело в том, что они могут использоваться для выполнения операций над числовыми значениями, ведь их действие распространяется скорее на ряд хранящихся в переменной битов (разрядов), чем на само ее значение.

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

Таблица 4.4. Таблица истинности операции &

Бит в первом операнде

1 1 О О

Бит во втором операнде

1 О 1 О

Бит результата &

1 О О О

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

Таблица 4.5. Таблица истинности операции

Бит в первом операнде Бит во втором операнде Бит результата

Например, рассмотрим показанную ниже операцию:

int result, opl, ор2; opl = 4; ор2 = 5;

result = opl & op2;

В этом случае требуется взять двоичные представления opl и ор2, которые выглядят, соответственно, как 100 и 101. Результат можно получить путем сравнения двоичных цифр, находящихся в этих двух представлениях в эквивалентных позициях, описанным ниже образом.

□ Если крайний левый бит и в opl ив ор2 равен 1, тогда крайний левый бит в result тоже будет равен 1, а если нет, тогда он будет равен 0.

□ Если следующий бит и в opl и в ор2 равен 1, тогда следующий бит в result тоже будет равен 1, а если нет, тогда он будет равен 0.

□ Сравнить таким же образом и все остальные биты.

В данном примере крайние левые биты у opl и ор2 равны 1, поэтому у result крайний левый бит тоже будет равен 1. Вторые биты у обоих равны О, а третьи - соответственно, 1 и О, поэтому второй и третий биты у result будут равны 0. Следовательно, конечное значение result в двоичном представлении будет выглядеть как 100, т.е. result получает значение 4. Весь этот процесс графически представлен ниже.

10 0 4

& 1 О 1 & 5

1 О О

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

10 0 4

110 1 15

1 О 1

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

Таблица 4.6. Таблица истинности операции

Бит в первом операнде Бит во втором операнде Бит результата

в языке С# также предусмотрена и возможность использования унарной поразрядной операции (~), действие которой заключается в инвертировании каждого из битов операнда, в результате чего получается переменная со значениями 1 для тех битов, которые в операнде равны О, и значениями О для тех битов, которые в операнде равны 1 (табл. 4.7).

Таблица 4.7. Таблица истинности операции

Способ, которым числа типа int сохраняются в .NET, также называемый дополнительным двоичным кодом, означает, что унарная операция ~ может приводить к получению результатов, выглядящих несколько странно. Если вспомнить, что тип int представляет собой состоящее из 32 битов число, например, тогда знание того, каким образом операция ~ воздействует на все эти 32 бита, может помочь увидеть, что же происходит. Например, число 5 в своем полном двоичном представлении будет выглядеть следующим образом:

000000000000000000000000000000101 А число -5 - так:

111111111111111111111111111111011

Дело в том, что в дополнительном двоичном коде (-х) на самом деле определяется как (~х + 1). Это может показаться странным, но такая система является очень удобной, когда дело доходит до сложения чисел. Например, сложение 10 и -5 (т.е. вычитание 5 из 10) в двоичном формате будет выглядеть следующим образом:

000000000000000000000000000001010 + 111111111111111111111111111111011 = 1000000000000000000000000000000101

Если не обращать внимания на 1 с самого края слева, тогда остается двоичное представление числа 5. Так что, хотя результаты вроде ~7 = -2и могут выглядеть странно, их такими делают лежащие в основе структуры.

Поразрядные операции, которые были продемонстрированы в этом разделе, являются довольно полезными в определенных ситуациях, поскольку позволяют легко использовать отдельные биты переменной для хранения нужной информации. Рассмотрим простой пример представления цвета с использованием трех битов для сохранения содержимого red, green и blue. Эти биты можно задать отдельно и сделать так, чтобы они предусматривали такие конфигурации, которые показаны в табл. 4.8.