Как делить в c
В C# используется большинство операций, которые применяются и в других языках программирования. Операции представляют определенные действия над операндами — участниками операции. В качестве операнда может выступать переменной или какое-либо значение (например, число). Операции бывают унарными (выполняются над одним операндом), бинарными — над двумя операндами и тернарными — выполняются над тремя операндами. Рассмотрим все виды операций.
Бинарные арифметические операции:
Операция сложения двух чисел:
Операция вычитания двух чисел:
Операция умножения двух чисел:
операция деления двух чисел:
При делении стоит учитывать, что если оба операнда представляют целые числа, то результат также будет округляться до целого числа:
Несмотря на то, что результат операции в итоге помещается в переменную типа double, которая позволяет сохранить дробную часть, но в самой операции участвуют два литерала, которые по умолчанию рассматриваются как объекты int, то есть целые числа, и результат то же будет целочисленный.
Для выхода из этой ситуации необходимо определять литералы или переменные, участвующие в операции, именно как типы double или float:
Операция получение остатка от целочисленного деления двух чисел:
Также есть ряд унарных операций, в которых принимает участие один операнд:
Инкремент бывает префиксным: ++x — сначала значение переменной x увеличивается на 1, а потом ее значение возвращается в качестве результата операции.
И также существует постфиксный инкремент: x++ — сначала значение переменной x возвращается в качестве результата операции, а затем к нему прибавляется 1.
Операция декремента или уменьшения значения на единицу. Также существует префиксная форма декремента ( —x ) и постфиксная ( x— ).
При выполнении сразу нескольких арифметических операций следует учитывать порядок их выполнения. Приоритет операций от наивысшего к низшему:
Умножение, деление, получение остатка
Для изменения порядка следования операций применяются скобки.
Рассмотрим набор операций:
Здесь мы имеем дело с тремя операциями: декремент, вычитание и умножение. Сначала выполняется декремент переменной c, затем умножение b*a, и в конце вычитание. То есть фактически набор операций выглядел так:
Но с помощью скобок мы могли бы изменить порядок операций, например, следующим образом:
Ассоциативность операторов
Как выше было отмечено, операции умножения и деления имеют один и тот же приоритет, но какой тогда результат будет в выражении:
Стоит нам трактовать это выражение как (10 / 5) * 2 или как 10 / (5 * 2) ? Ведь в зависимости от трактовки мы получим разные результаты.
Когда операции имеют один и тот же приоритет, порядок вычисления определяется ассоциативностью операторов. В зависимости от ассоциативности есть два типа операторов:
Левоассоциативные операторы, которые выполняются слева направо
Правоассоциативные операторы, которые выполняются справа налево
Все арифметические операторы являются левоассоциативными, то есть выполняются слева направо. Поэтому выражение 10 / 5 * 2 необходимо трактовать как (10 / 5) * 2 , то есть результатом будет 4.
Арифметические действия в языке Си
Программы работают с данными. Зачастую данные представляют собой числа. В этом уроке, как вы наверное догадались, мы будем заниматься изучением того, как и что в языке Си можно делать с числами. Начнём с арифметики.
Компилятор языка Си понимает все основные арифметические операции, которые вам известны со школы. Плюс есть несколько дополнительных.
Основные арифметические операторы языка Си.
+ оператор сложения
— оператор вычитания
* оператор умножения
% оператор взятия остатка от деления
/ оператор деления
Следующая программа иллюстрирует использование первых четырёх из них. Кстати, обратите внимание на то, как с помощью функции printf вывести на экран символ % .
Результат работы этой программы представлен на следующем рисунке.
Рис.5 Использование арифметических действий в Си.
Всё чётко и понятно. Никаких неожиданностей. А теперь попробуем получить частное двух чисел. Т.к. результат должен получиться 3.5, то res объявим как float .
Как видите, результат получился не тот, что мы ожидали. Это одна из особенностей оператора деления в языке Си.
При делении значение целого типа на значение целого типа результат тоже получается целого типа.
Так уж устроен язык Си. Поэкспериментируйте, попробуйте любые другие целые числа.
Вычислить результат целочисленного деления легко. Поделите числа и отбросьте всё, что получилось в дробной части.
Пример: Как получить результат целочисленного деления
7/2 = 3.5 → 3
11/3 = 3.66 → 3
2/5 = 0.4 → 0
Для того чтобы получить тот результат, который мы в данном случае ожидаем, одно из значений нужно сделать вещественным. Сделать это проще простого. Для этого необходимо рядом с ним в скобках записать float .
Посмотрим на нашем примере:
Теперь результат будет тот, что мы ожидали. Проделанный нами трюк называется явным преобразованием типа .
Явное преобразование (приведение) типа.
Если какое-то значение нужно привести к другому типу, нужно перед этим значением в скобках написать название требуемого типа.
Листинг 4. Примеры явного преобразования типа
Важный момент: преобразуется не тип исходной переменной, а только лишь значение, которое используется в выражении. В следующем видео-фрагменте об этом говорится подробнее.
Обратите внимание, что, когда мы преобразовываем целое значение в вещественное, ничего особенного не происходит, т.к. вещественные числа включают в себя целые.
Совсем иная ситуация, когда мы от вещественного переходим к целому. При этом переходе у нас теряется вся дробная часть. Не забывайте об этом.
Картинка, показывающая различия между операциями взятие остатка, целочисленного деления и обычного деления.
Рис.2 Деление, целочисленное деление и остаток от деления.
Сохрани в закладки или поддержи проект.
Практика
Решите предложенные задачи:
Для удобства работы сразу переходите в полноэкранный режим 
5.2 – Арифметические операторы
В C++ есть два унарных арифметических оператора, плюс (+) и минус (-). Напоминаем, что унарные операторы – это операторы, которые принимают только один операнд.
| Оператор | Обозначение | Пример использования | Операция |
|---|---|---|---|
| Унарный плюс | + | +x | Значение x |
| Унарный минус | — | -x | Отрицательное значение x |
Оператор унарного минуса возвращает операнд, умноженный на -1 . Другими словами, если x = 5 , -x равно -5 .
Оператор унарного плюса возвращает значение операнда. Другими словами, +5 равно 5 , а +x равно x . Как правило, вам не нужно использовать этот оператор, поскольку он избыточен. Он был добавлен в основном для обеспечения симметрии с унарным оператором минус.
Для наилучшего эффекта оба этих оператора следует размещать непосредственно перед операндом (например, -x , а не — x ).
Не путайте оператор унарного минуса с оператором бинарного вычитания, в котором используется тот же символ. Например, в выражении x = 5 — -3; первый минус – это оператор бинарного вычитания, а второй – оператор унарного минуса.
Бинарные арифметические операторы
В C++ есть 5 бинарных арифметических операторов. Бинарные операторы – это операторы, которые принимают левый и правый операнды.
| Оператор | Обозначение | Пример использования | Операция |
|---|---|---|---|
| Сложение | + | x + y | x плюс y |
| Вычитание | — | x — y | x минус y |
| Умножение | * | x * y | x , умноженное на y |
| Деление | / | x / y | x , деленное на y |
| Остаток от деления | % | x % y | остаток от деления x на y |
Операторы сложения, вычитания и умножения работают так же, как и в реальной жизни, без каких-либо оговорок.
Деление и остаток от деления требуют дополнительных пояснений. О делении мы поговорим ниже, а об остатке от деления – в следующем уроке.
Целочисленное деление и деление с плавающей запятой
Проще всего представить себе, что оператор деления имеет два разных «режима».
Если один (или оба) операнда являются значениями с плавающей точкой, оператор деления выполняет деление с плавающей точкой. Деление с плавающей точкой возвращает значение с плавающей точкой, и дробная часть сохраняется. Например, 7.0 / 4 = 1.75 , 7 / 4.0 = 1.75 и 7.0 / 4.0 = 1.75 . Как и во всех арифметических операциях с плавающей точкой, здесь могут возникать ошибки округления.
Если оба операнда являются целыми числами, оператор деления вместо этого выполняет целочисленное деление. Целочисленное деление отбрасывает любые дробные части и возвращает целочисленное значение. Например, 7 / 4 = 1 , потому что дробная часть результата отбрасывается. Точно так же -7 / 4 = -1 , потому что дробная часть опускается.
Предупреждение
До C++11 целочисленное деление с отрицательным операндом могло округляться в большую или меньшую сторону. Таким образом, -5 / 3 могло дать результат -1 или -2 . Это было исправлено в C++11, где дробная часть всегда отбрасывается (округляется до 0).
Использование static_cast<> для деления с плавающей точкой с целочисленными значениями
Сказанное выше поднимает вопрос: если у нас есть два целых числа и мы хотим разделить их без потери дробной части, как нам это сделать?
В уроке «4.11 – Символы» мы показали, как можно использовать оператор static_cast<> для преобразования значения char в целочисленный тип, чтобы оно печаталось как целое число, а не как символ.
Аналогичным образом мы можем использовать static_cast<> для преобразования значения целочисленного типа в число с плавающей точкой, чтобы мы, вместо целочисленного деления, смогли выполнить деление с плавающей точкой. Рассмотрим следующий код:
Приведенный выше пример показывает, что если любой из операндов является числом с плавающей точкой, результатом будет деление с плавающей точкой, а не целочисленное деление.
Деление на ноль
Попытка разделить на 0 (или 0.0) обычно приводит к сбою программы, так как результаты математически не определены!
Это работает, но немного неудобно и требует для выполнения двух операторов ( operator+ и operator= ).
Поскольку написание таких инструкций, как x = x + 4 , очень распространено, C++ для удобства предоставляет пять арифметических операторов присваивания. Вместо того, чтобы писать x = x + 4 , вы можете написать x += 4 . Вместо x = x * y вы можете написать x *= y .
Name already in use
csharp_for_beginners / c4.md
- Go to file T
- Go to line L
- Copy path
- Copy permalink
- Open with Desktop
- View raw
- Copy raw contents Copy raw contents
Copy raw contents
Copy raw contents
ГЛАВА 4. Операторы
В языке C# предусмотрен обширный ряд операторов, предоставляющих программирующему возможность полного контроля над построением и вычислением выражений. Большинство операторов в С# относится к сле дующим категориям: арифметические, поразрядные, логиче ские и операторы отношения. Все перечисленные категории операторов рассматриваются в этой главе. Кроме того, в C# предусмотрен ряд других операторов для особых случаев, включая индексирование массивов, доступ к членам класса и обработку лямбда-выражений. Эти специальные опера торы рассматриваются далее в книге вместе с теми сред ствами, в которых они применяются.
Арифметические операторы, представленные в языке С#, приведены ниже.
| Оператор | Действие |
|---|---|
| + | Сложение |
| — | Вычитание, унарный минус |
| * | Умножение |
| / | Деление |
| % | Деление по модулю |
| — | Декремент |
| ++ | Инкремент |
Операторы +, -, * и / действуют так, как предполагает их обозначение. Их можно применять к любому встроенному числовому типу данных.
Действие арифметических операторов не требует особых пояснений, за исключени ем следующих особых случаев. Прежде всего, не следует забывать, что когда оператор / применяется к целому числу, то любой остаток от деления отбрасывается; например, результат целочисленного деления 10/3 будет равен 3. Остаток от этого деления можно получить с помощью оператора деления по модулю (%), который иначе называется оператором вычисления остатка. Он дает остаток от целочисленного деления. Напри мер, 10 % 3 равно 1. В C# оператор % можно применять как к целочисленным типам данных, так и к типам с плавающей точкой. Поэтому 10.0 % 3.0 также равно 1. В этом отношении C# отличается от языков С и C++, где операции деления по модулю разрешаются только для целочисленных типов данных. В приведенном ниже примере программы демонстрируется применение оператора деления по модулю.
Результат выполнения этой программы приведен ниже.
Как видите, обе операции, % целочисленного типа и с плавающей точкой, дают один и тот же остаток, равный 1.
Операторы инкремента и декремента
Операторы инкремента (++) и декремента (—) были представлены в главе 2. Как станет ясно в дальнейшем, они обладают рядом особых и довольно интересных свойств. Но сначала выясним основное назначение этих операторов.
Оператор инкремента увеличивает свой операнд на 1, а оператор декремента уменьшает операнд на 1. Следовательно, оператор
Следует, однако, иметь в виду, что в инкрементной или декрементной форме зна чение переменной х вычисляется только один, а не два раза. В некоторых случаях это позволяет повысить эффективность выполнения программы.
Оба оператора инкремента и декремента можно указывать до операнда (в префикс ной форме) или же после операнда (в постфиксной форме). Например, оператор
может быть записан в следующем виде:
или же в таком виде:
В приведенном выше примере форма инкремента (префиксная или постфиксная) особого значения не имеет. Но если оператор инкремента или декремента использу ется в длинном выражении, то отличие в форме его записи уже имеет значение. Когда оператор инкремента или декремента предшествует своему операнду, то результатом операции становится значение операнда после инкремента или декремента. А когда оператор инкремента или декремента следует после своего операнда, то результатом операции становится значение операнда до инкремента или декремента. Рассмотрим следующий фрагмент кода.
В данном случае значение переменной у будет установлено равным 11, поскольку значение переменной х сначала увеличивается на 1, а затем присваивается переменной у. Но во фрагменте кода
значение переменной у будет установлено равным 10, так как в этом случае значение переменной х сначала присваивается переменной у, а затем увеличивается на 1. В обо их случаях значение переменной х оказывается равным 11. Отличие состоит лишь том, когда именно это значение станет равным 11: до или после его присваивания пере менной у.
Возможность управлять моментом инкремента или декремента дает немало пре имуществ при программировании. Обратимся к следующему примеру программы, в которой формируется последовательный ряд чисел.
Выполнение этой программы дает следующий результат.
Как подтверждает приведенный выше результат, в операторе
первоначальное значение переменной х складывается с самим собой, а полученный результат присваивается переменной у. После этого значение переменной х увеличи вается на 1. Но в операторе
значение переменной х сначала увеличивается на 1, затем складывается с первоначаль ным значением этой же переменной, а полученный результат присваивается пере менной у. Как следует из приведенного выше результата, простая замена префиксной формы записи оператора ++х постфиксной формой х++ приводит к существенному изменению последовательного ряда получаемых чисел.
И еще одно замечание по поводу приведенного выше примера: не пугайтесь выра жений, подобных следующему:
Такое расположение рядом двух операторов может показаться не совсем привыч ным, но компилятор воспримет их в правильной последовательности. Нужно лишь запомнить, что в данном выражении значение переменной у складывается с увеличен ным на 1 значением переменной х.
Операторы отношения и логические операторы
В обозначениях оператор отношения и логический оператор термин отношения озна чает взаимосвязь, которая может существовать между двумя значениями, а термин логический — взаимосвязь между логическими значениями «истина» и «ложь». И по скольку операторы отношения дают истинные иди ложные результаты, то они неред ко применяются вместе с логическими операторами. Именно по этой причине они и рассматриваются совместно в данном разделе.
Ниже перечислены операторы отношения.
| Оператор | Значение |
|---|---|
| == | Равно |
| != | Не равно |
| > | Больше |
| < | Меньше |
| > | Больше или равно |
| <= | Меньше или равно |
К числу логических относятся операторы, приведенные ниже.
Результатом выполнения оператора отношения или логического оператора являет ся логическое значение типа bool.
В целом, объекты можно сравнивать на равенство или неравенство, используя опе раторы отношения == и !=. А операторы сравнения <, >, <= или >= могут применяться только к тем типам данных, которые поддерживают отношение порядка. Следователь но, операторы отношения можно применять ко всем числовым типам данных. Но зна чения типа bool могут сравниваться только на равенство или неравенство, поскольку истинные (true) и ложные (false) значения не упорядочиваются. Например, сравне ние true > false в C# не имеет смысла.
Операнды логических операторов должны относиться к типу bool, а результат вы полнения логической операции также относится к типу bool. Логические операторы &, |, ^ и ! поддерживают основные логические операции И, ИЛИ, исключающее ИЛИ и НЕ в соответствии с приведенной ниже таблицей истинности.
| p | q | p & q | p | q | p ^ q | |P |
|---|---|---|---|---|---|
| false | false | false | false | false | true |
| true | false | false | true | true | false |
| false | true | false | true | true | true |
| true | true | true | true | false | false |
Как следует из приведенной выше таблицы, результатом выполнения логической операции исключающее ИЛИ будет истинное значение (true), если один и только один ее операнд имеет значение true.
Ниже приведен пример программы, демонстрирующий применение нескольких операторов отношения и логических операторов.
Выполнение этой программы дает следующий результат.
Логические операторы в C# выполняют наиболее распространенные логические операции. Тем не менее существует ряд операций, выполняемых по правилам фор мальной логики. Эти логические операции могут быть построены с помощью логиче ских операторов, поддерживаемых в С#. Следовательно, в C# предусмотрен такой на бор логических операторов, которого достаточно для построения практически любой логической операции, в том числе импликации. Импликация — это двоичная опера ция, результатом которой является ложное значение только в том случае, если левый ее операнд имеет истинное значение, а правый — ложное. (Операция импликации от ражает следующий принцип: истина не может подразумевать ложь.) Ниже приведена таблица истинности для операции импликации.
| p | q | Результат импликации p и q |
|---|---|---|
| true | true | true |
| true | false | false |
| false | false | true |
| false | true | true |
Операция импликации может быть построена на основе комбинации логических операторов ! и |, как в приведенной ниже строке кода.
В следующем примере программы демонстрируется подобная реализация опера ции импликации.
Результат выполнения этой программы выглядит так.
Укороченные логические операторы
В C# предусмотрены также специальные, укороченные, варианты логических опера торов И и ИЛИ, предназначенные для получения более эффективного кода. Поясним это на следующих примерах логических операций. Если первый операнд логической операции И имеет ложное значение (false), то ее результат будет иметь ложное зна чение независимо от значения второго операнда. Если же первый операнд логической операции ИЛИ имеет истинное значение (true), то ее результат будет иметь истинное значение независимо от значения второго операнда. Благодаря тому что значение вто рого операнда в этих операциях вычислять не нужно, экономится время и повышается эффективность кода.
Укороченная логическая операция И выполняется с помощью оператора &&, а уко роченная логическая операция ИЛИ — с помощью оператора ||. Этим укороченным логическим операторам соответствуют обычные логические операторы & и |. Един ственное отличие укороченного логического оператора от обычного заключается в том, что второй его операнд вычисляется только по мере необходимости.
В приведенном ниже примере программы демонстрируется применение укорочен ного логического оператора И. В этой программе с помощью операции деления по модулю определяется следующее: делится ли значение переменной d на значение пе ременной n нацело. Если остаток от деления n/d равен нулю, то n делится на d нацело. Но поскольку данная операция подразумевает деление, то для проверки условия деле ния на нуль служит укороченный логический оператор И.
Для исключения ошибки из-за деления на нуль в операторе if сначала проверяет ся условие: равно ли нулю значение переменной d. Если оно равно нулю, то на этом выполнение укороченного логического оператора И завершается, а последующая опе рация деления по модулю не выполняется. Так, при первой проверке значение пере менной d оказывается равным 2, поэтому выполняется операция деления по модулю. А при второй проверке это значение оказывается равным нулю, следовательно, опера ция деления по модулю пропускается, чтобы исключить деление на нуль. И наконец, выполняется обычный логический оператор И, когда вычисляются оба операнда. Если при этом происходит деление на нуль, то возникает ошибка при выполнении.
Укороченные логические операторы иногда оказываются более эффективными, чем их обычные аналоги. Так зачем же нужны обычные логические операторы И и ИЛИ? Дело в том, что в некоторых случаях требуется вычислять оба операнда логи ческой операции И либо ИЛИ из-за возникающих побочных эффектов. Рассмотрим следующий пример программы.
Прежде всего обратим внимание на то, что переменная someCondition типа bool инициализируется значением false. Далее проанализируем каждый оператор if. Как следует из комментариев к данной программе, в первом операторе if перемен ная i инкрементируется, несмотря на то что значение переменной someCondition равно false. Когда применяется логический оператор &, как это имеет место в первом операторе if, выражение в правой части этого оператора вычисляется независимо от значения выражения в его левой части. А во втором операторе if применяется укоро ченный логический оператор. В этом случае значение переменной i не инкрементиру ется, поскольку левый операнд (переменная someCondition) имеет значение false, следовательно, выражение в правой части данного оператора пропускается. Из этого следует вывод: если в коде предполагается вычисление правого операнда логической операции И либо ИЛИ, то необходимо пользоваться неукороченными формами логи ческих операций, доступных в С#.
И последнее замечание: укороченный оператор И называется также условным логи ческим оператором И, а укороченный оператор ИЛИ — условным логическим оператором ИЛИ.
Оператор присваивания обозначается одиночным знаком равенства (=). В С# опера тор присваивания действует таким же образом, как и в других языках программирова ния. Ниже приведена его общая форма.
Здесь имя_переменной должно быть совместимо с типом выражения.
У оператора присваивания имеется одна интересная особенность, о которой вам будет полезно знать: он позволяет создавать цепочку операций присваивания. Рассмо трим, например, следующий фрагмент кода.
В приведенном выше фрагменте кода одно и то же значение 100 задается для пе ременных х, у и z с помощью единственного оператора присваивания. Это значение присваивается сначала переменной z, затем переменной у и, наконец, переменной х. Такой способ присваивания «по цепочке» удобен для задания общего значения целой группе переменных.
Составные операторы присваивания
В C# предусмотрены специальные составные операторы присваивания, упрощаю щие программирование некоторых операций присваивания. Обратимся сначала к простому примеру. Приведенный ниже оператор присваивания
можно переписать, используя следующий составной оператор присваивания.
Пара операторов += указывает компилятору на то, что переменной х должно быть присвоено ее первоначальное значение, увеличенное на 10.
Рассмотрим еще один пример. Оператор
выполняют одни и те же действия. Оба оператора присваивают переменной х ее пер воначальное значение, уменьшенное на 100.
Для многих двоичных операций, т.е. операций, требующих наличия двух операн дов, существуют отдельные составные операторы присваивания. Общая форма всех этих операторов имеет следующий вид;
где ор — арифметический или логический оператор, применяемый вместе с операто ром присваивания.
Ниже перечислены составные операторы присваивания для арифметических и ло гических операций.
Составные операторы присваивания записываются более кратко, чем их несо ставные эквиваленты. Поэтому их иногда еще называют укороченными операторами присваивания.
У составных операторов присваивания имеются два главных преимущества. Во- первых, они более компактны, чем их «несокращенные» эквиваленты. И во-вторых, они дают более эффективный исполняемый код, поскольку левый операнд этих операторов вычисляется только один раз. Именно по этим причинам составные операторы присва ивания чаще всего применяются в программах, профессионально написанных на С#.
В C# предусмотрен ряд поразрядных операторов, расширяющих круг задач, для ре шения которых можно применять С#. Поразрядные операторы воздействуют на от дельные двоичные разряды (биты) своих операндов. Они определены только для цело численных операндов, поэтому их нельзя применять к данным типа bool, float или double.
Эти операторы называются поразрядными, поскольку они служат для проверки, установки или сдвига двоичных разрядов, составляющих целое значение. Среди про чего поразрядные операторы применяются для решения самых разных задач програм мирования на уровне системы, включая, например, анализ информации состояния устройства. Все доступные в C# поразрядные операторы приведены в табл. 4.1.
Таблица 4.1. Поразрядные операторы
Поразрядные операторы И, ИЛИ, исключающее ИЛИ и НЕ
Поразрядные операторы И, ИЛИ, исключающее ИЛИ и НЕ обозначаются следую щим образом: &, |, ^ и
. Они выполняют те же функции, что и их логические аналоги, рассмотренные выше. Но в отличие от логических операторов, поразрядные операто ры действуют на уровне отдельных двоичных разрядов. Ниже приведены результаты поразрядных операций с двоичными единицами и нулями.
С точки зрения наиболее распространенного применения поразрядную операцию И можно рассматривать как способ подавления отдельных двоичных разрядов. Это означает, что если какой-нибудь бит в любом из операндов равен 0, то соответствую щий бит результата будет сброшен в 0. Например:
В приведенном ниже примере программы демонстрируется применение пораз рядного оператора & для преобразования нечетных чисел в четные. Для этой цели достаточно сбросить младший разряд числа. Например, число 9 имеет следующий двоичный вид: 0000 1001. Если сбросить младший разряд этого числа, то оно станет числом 8, а в двоичной форме — 0000 1000.
Результат выполнения этой программы приведен ниже.
Шестнадцатеричное значение 0xFFFE, используемое в поразрядном операторе И, имеет следующую двоичную форму: 1111 1111 1111 1110. Таким образом, пораз рядная операция И оставляет без изменения все двоичные разряды в числовом значе нии переменной num, кроме младшего разряда, который сбрасывается в нуль. В итоге четные числа не претерпевают никаких изменений, а нечетные уменьшаются на 1 и становятся четными.
Поразрядным оператором И удобно также пользоваться для определения уста новленного или сброшенного состояния отдельного двоичного разряда. В следующем примере программы определяется, является ли число нечетным.
Вот как выглядит результат выполнения этой программы.
В обоих операторах if из приведенной выше программы выполняется поразрядная операция И над числовыми значениями переменной num и 1. Если младший двоич ный разряд числового значения переменной num установлен, т.е. содержит двоичную 1, то результат поразрядной операции num & 1 оказывается равным 1. В противном случае он равен нулю. Поэтому оператор if может быть выполнен успешно лишь в том случае, если проверяемое число оказывается нечетным.
Возможностью проверять состояние отдельных двоичных разрядов с помощью по разрядного оператора & можно воспользоваться для написания программы, в которой отдельные двоичные разряды проверяемого значения типа byte приводятся в двоич ной форме. Ниже показан один из способов написания такой программы.
Выполнение этой программы дает следующий результат.
В цикле for из приведенной выше программы каждый бит значения переменной val проверяется с помощью поразрядного оператора И, чтобы выяснить, установлен ли этот бит или сброшен. Если он установлен, то выводится цифра 1, а если сброшен, то выводится цифра 0.
Поразрядный оператор ИЛИ может быть использован для установки отдельных дво ичных разрядов. Если в 1 установлен какой-нибудь бит в любом из операндов этого опе ратора, то в 1 будет установлен и соответствующий бит в другом операнде. Например:
Используя поразрядный оператор ИЛИ, можно без особого труда превратить упо минавшийся выше пример программы, преобразующей нечетные числа в четные, в приведенный ниже обратный пример, где четные числа преобразуются в нечетные.
Результат выполнения этой программы выглядит следующим образом.
В приведенной выше программе выполняется поразрядная операция ИЛИ над каждым числовым значением переменной num и 1, поскольку 1 дает двоичное значе ние, в котором установлен младший разряд. В результате поразрядной операции ИЛИ над 1 и любым другим значением младший разряд последнего устанавливается, тогда как все остальные разряды остаются без изменения. Таким образом, результирующее числовое значение получается нечетным, если исходное значение было четным.
Поразрядный оператор исключающее ИЛИ устанавливает двоичный разряд опе ранда в том и только в том случае, если двоичные разряды сравниваемых операндов оказываются разными, как в приведенном ниже примере.
У поразрядного оператора исключающее ИЛИ имеется одно интересное свойство, которое оказывается полезным в самых разных ситуациях. Так, если выполнить снача ла поразрядную операцию исключающее ИЛИ одного значения X с другим значением Y, а затем такую же операцию над результатом предыдущей операции и значением Y, то вновь получится первоначальное значение X. Это означает, что в приведенном ниже фрагменте кода
значение переменной R2 оказывается в итоге таким же, как и значение переменной X. Следовательно, в результате двух последовательно выполняемых поразрядных опера ций исключающее ИЛИ, в которых используется одно и то же значение, подучается первоначальное значение. Этим свойством данной операции можно воспользоваться для написания простой программы шифрования, в которой некоторое целое значение служит в качестве ключа для кодирования и декодирования сообщения с помощью операции исключающее ИЛИ над символами этого сообщения. В первый раз опера ция исключающее ИЛИ выполняется для кодирования открытого текста в зашифро ванный, а второй раз — для декодирования зашифрованного текста в открытый. Разу меется, такое шифрование не представляет никакой практической ценности, посколь ку оно может быть легко разгадано. Тем не менее оно служит интересным примером для демонстрации результатов применения поразрядных операторов исключающее ИЛИ, как в приведенной ниже программе.
Ниже приведен результат выполнения этой программы.
Как видите, в результате выполнения двух последовательностей поразрядных опе раций исключающее ИЛИ получается расшифрованное сообщение. (Еще раз напом ним, что такое шифрование не имеет никакой практической ценности, поскольку оно, в сущности, ненадежно.)
Поразрядный унарный оператор НЕ (или оператор дополнения до 1) изменяет на обратное состояние всех двоичных разрядов операнда. Так, если некоторое целое зна чение А имеет комбинацию двоичных разрядов 1001 0110, то в результате поразрядной операции
А получается значение с комбинацией двоичных разрядов 0110 1001.
В следующем примере программы демонстрируется применение поразрядного оператора НЕ с выводом некоторого числа и его дополнения до 1 в двоичном коде.
Результат выполнения этой программы приведен ниже.
В C# имеется возможность сдвигать двоичные разряды, составляющие целое зна чение, влево или вправо на заданную величину. Для этой цели в C# определены два приведенных ниже оператора сдвига двоичных разрядов.
| << | Сдвиг влево |
| >> | Сдвиг вправо |
Ниже приведена общая форма для этих операторов:
где число_битов — это число двоичных разрядов, на которое сдвигается указанное значение.
При сдвиге влево все двоичные разряды в указываемом значении сдвигаются на одну позицию влево, а младший разряд сбрасывается в нуль. При сдвиге вправо все двоичные разряды в указываемом значении сдвигаются на одну позицию вправо. Если вправо сдвигается целое значение без знака, то старший разряд сбрасывается в нуль. А если вправо сдвигается целое значение со знаком, то разряд знака сохраняется. На помним, что для представления отрицательных чисел старший разряд целого числа устанавливается в 1. Так, если сдвигаемое значение является отрицательным, то при каждом сдвиге вправо старший разряд числа устанавливается в 1. А если сдвигаемое значение является положительным, то при каждом сдвиге вправо старший разряд чис ла сбрасывается в нуль.
При сдвиге влево и вправо крайние двоичные разряды теряются. Восстановить по терянные при сдвиге двоичные разряды нельзя, поскольку сдвиг в данном случае не является циклическим.
Ниже приведен пример программы, наглядно демонстрирующий действие сдвига влево и вправо. В данном примере сначала задается первоначальное целое значение, равное 1. Это означает, что младший разряд этого значения установлен. Затем это це лое значение сдвигается восемь раз подряд влево. После каждого сдвига выводятся во семь младших двоичных разрядов данного значения. Далее процесс повторяется, но на этот раз 1 устанавливается на позиции восьмого разряда, а по существу, задается целое значение 128, которое затем сдвигается восемь раз подряд вправо.
Результат выполнения этой программы выглядит следующим образом.
Двоичные разряды соответствуют форме представления чисел в степени 2, и поэто му операторы сдвига могут быть использованы для умножения или деления целых значений на 2. Так, при сдвиге вправо целое значение удваивается, а при сдвиге вле во — уменьшается наполовину. Разумеется, все это справедливо лишь в том случае, если крайние разряды не теряются при сдвиге в ту или иную сторону. Ниже приведен соответствующий пример.
Ниже приведен результат выполнения этой программы.
Обратите внимание на последнюю строку приведенного выше результата. Когда целое значение 10 сдвигается влево тридцать раз подряд, информация теряется, по скольку двоичные разряды сдвигаются за пределы представления чисел для типа int. В данном случае получается совершенно «непригодное» значение, которое оказывается к тому же отрицательным, поскольку в результате сдвига в старшем разряде, исполь зуемом в качестве знакового, оказывается 1, а следовательно, данное числовое значение должно интерпретироваться как отрицательное. Этот пример наглядно показывает, что применять операторы сдвига для умножения иди деления на 2 следует очень акку ратно. (Подробнее о типах данных со знаком и без знака см. в главе 3.)
Поразрядные составные операторы присваивания
Все двоичные поразрядные операторы могут быть использованы в составных опе рациях присваивания. Например, в двух приведенных ниже операторах переменной х присваивается результат выполнения операции исключающее ИЛИ над первона чальным значением переменной х и числовым значением 127.
Оператор ? относится к числу самых примечательных в С#. Он представляет со бой условный оператор и часто используется вместо определенных видов конструкций if-then-else. Оператор ? иногда еще называют тернарным, поскольку для него тре буются три операнда. Ниже приведена общая форма этого оператора.
Здесь Выражение1 должно относиться к типу bool, а Выражение2 и Выражение3 — к одному и тому же типу. Обратите внимание на применение двоеточия и его место положение в операторе ?.
Значение выражения ? определяется следующим образом. Сначала вычисляется Выражение1. Если оно истинно, то вычисляется Выражение2, а полученный результат определяет значение всего выражения ? в целом. Если же Выражение1 оказывается ложным, то вычисляется Выражение3, и его значение становится общим для всего вы ражения ?. Рассмотрим следующий пример, в котором переменной absval присваи вается значение переменной val.
В данном примере переменной absval присваивается значение переменной val, если оно больше или равно нулю. Если же значение переменной val отрицательно, то переменной absval присваивается результат отрицания этого значения, что в итоге дает положительное значение.
Ниже приведен еще один пример применения оператора ?. В данной программе одно число делится на другое, но при этом исключается деление на нуль.
Выполнение этой программы дает следующий результат.
Обратите особое внимание на следующую строку из приведенной выше программы.
В этой строке переменной result присваивается результат деления числа 100 на значение переменной i. Но это деление осуществляется лишь в том случае, если зна чение переменной i не равно нулю. Когда же оно равно нулю, переменной result присваивается значение, обнуляющее результат.
Присваивать переменной результат выполнения оператора ? совсем не обязатель но. Например, значение, которое дает оператор ?, можно использовать в качестве аргу мента при вызове метода. А если все выражения в операторе ? относятся к типу bool, то такой оператор может заменить собой условное выражение в цикле или операторе if. В приведенном ниже примере программы выводятся результаты деления числа 100 только на четные, ненулевые значения.
Обратите внимание на оператор if в приведенной выше программе. Если значение переменной i равно нулю, то оператор if дает ложный результат. А если значение переменной i не равно нулю, то оператор if дает истинный результат, когда значение переменной i оказывается четным, и ложный результат, если оно нечетное. Благодаря этому допускается деление только на четные и ненулевые значения. Несмотря на то что данный пример служит лишь для целей демонстрации, подобные конструкции иногда оказываются весьма полезными.
Использование пробелов и круглых скобок
В выражении на C# допускается наличие символов табуляции и пробелов, благо даря которым оно становится более удобным для чтения. Например, оба приведенных ниже выражения, по существу, одинаковы, но второе читается легче.
Скобки могут служить для группирования подвыражений, по существу, повышая порядок предшествования заключенных в них операций, как в алгебре. Применение лишних или дополнительных скобок не приводит к ошибкам и не замедляет вычис ление выражения. Поэтому скобки рекомендуется использовать, чтобы сделать более ясным и понятным порядок вычисления как для самого автора программы, так и для тех, кто будет разбираться в ней впоследствии. Например, какое из двух приведенных ниже выражение легче читается?
В табл. 4.2 приведен порядок предшествования всех операторов в С#: от самого вы сокого до самого низкого. В таблицу включен ряд операторов, рассматриваемых далее в этой книге.