Математические операторы
В языке С# имеются математические операторы, предназначенные для сложения, вычитания, умножения, деления и вычисления остатка от деления. Эти операторы, а также используемые для их обозначения символы приведены в следующей таблице:
Символ |
Оператор |
+ |
Сложение |
– |
Вычитание |
* |
Умножение |
/ |
Деление |
% |
Вычисление остатка при целочисленном делении |
Таблица. Математические операторы
Рассмотрим использование этих операторов в программах С#.
Сложение и вычитание
При помощи оператора сложения можно складывать содержимое числовых переменных и числовых литералов. Результат операции должен быть записан в переменную, т. е. в объект типа lvalue .
Результат операции сложения получается путем вычисления суммы двух складываемых величин. Так как в операции принимают участие два операнда, операция сложения называется бинарной (binary). Помимо бинарных операторов имеются еще и так называемые унарные (unary) операторы, имеющие дело только с одним операндом. Унарные операторы будут рассмотрены позже в этом разделе курса.
В операции вычитания, так же как и в только что рассмотренной операции сложения, принимают участие два операнда, например:
int х = 4;
int у = 2;
int z = х - у;
Здесь в переменную z записывается результат вычитания значения переменной у из значения переменной х. В операции вычитания могут принимать участие и числовые литералы, например:
int х = 4;
int z = х - 5;
После выполнения этой операции в переменную z будет записано отрицательное значение -1 .
Для демонстрации применений операторов сложения и вычитания рассмотрим следующую простую программу, исходный текст которой представлен ниже:
using System;
namespace MathOperators
{
class MathOperatorsApp
{
static void Main(string[] args)
{
int x, y, z;
x = 1;
y = 5 - 2;
z = x + y + 10;
System.Console.WriteLine("x = {0}, у = {1}, z = {2}",
x, y, z) ;
System.Console.WriteLine("Сложение и вычитание");
System.Console.ReadLine();
}
}
}
В первой строке метода Main, получающего управление при запуске программы, мы объявили 3 переменные типа int с именами х, у и z:
int x, у, z;
Для инициализации переменной х мы использовали числовой литерал 1:
х = 1;
Здесь пока нет для нас ничего нового. Но вот в следующей строке для инициализации переменной у мы использовали разность двух числовых литералов:
У = 5 - 2;
В результате переменная у будет содержать значение 3. Далее мы инициализируем переменную z:
z = x + y + 10;
В нее записывается сумма значений, хранящихся в переменных х и у, к которой прибавляется число 10.
После выполнения всех этих действий содержимое наших числовых переменных выводится на консоль при помощи известного вам метода WriteLine:
System.Console.WriteLine("x = {0}, у = {1}, z = {2}", x, y, z) ;
Здесь использован новый формат вызова метода WriteLine. Теперь этому методу передаются несколько параметров (в данном случае четыре), разделенных запятыми. Первый из них представляет собой строковый литерал, а остальные — числовые переменные, значения которых нас интересуют.
Метод WriteLine обладает большими возможностями, но мы будем изучать их постепенно по мере изложения материала. В данном случае мы передали методу в качестве первого параметра так называемую строку формата, определяющую, что и как нужно выводить на консоль. Остальные параметр представляет собой переменные, содержимое которой нужно вывести.
Во время работы программы метод WriteLine вначале выведет на консоль строку "x = ", а затем вместо конструкции "{0}" подставит значение второго параметра метода, т. е. содержимое переменной х. После этого строка форматирования просматривается дальше, значения "y = " и "z = " выводятся на экран без изменения, а вместо "{1}" и "{2}" подставляются значения следующих параметров метода, т. е. содержимое переменных y и z соответственно.
Вот что появится в консольном окне после запуска программы:
Теперь добавим в программу следующий фрагмент кода:
uint uX = 2;
System.Console.WriteLine(" 2 - 3 = {0} ", uX - 3);
Здесь мы объявили переменную без знака типа uint с именем uX, записав в нее число 2. Затем мы вывели на консоль результат вычитания из содержимого этой переменной значения 3.
Вот что получится на консоли после запуска этой программы:
В первой строке все правильно. Что же касается второй строки, то в результате вычитания из числа 2 числа 3 мы получили ни много, ни мало... 4 294 967 295! В чем причина ошибки?
Все дело в том, что мы попытались использовать в операции вычитания переменную без знака uX. Вспомните, что для представления знака числа используется его старший разряд. Если число отрицательное, этот разряд установлен (равен 1).
При вычитании из 2 числа 3 должно получиться число -1 . В шестнадцатеричном представлении 32-разрядное число -1 записывается как 0xFFFFFFFF. Выполнив преобразование десятичного числа 4 294 967 295 в шестнадцатеричное, например, при помощи стандартного калькулятора Microsoft Windows, вы сможете убедиться, что это число как раз равно 0xFFFFFFFF.
Но так как тип первого операнда (переменная иХ) — целое число без знака, то отрицательный результат вычитания 0xFFFFFFFF трактуется как большое положительное число.
Составляя выражения для выполнения математических вычислений, очень важно правильно выбирать типы переменных, иначе появятся ошибки. Компилятор С# не сможет обнаружить ошибки подобного рода, потому что ему не известно, с какими числами (со знаком или без знака) вы собираетесь работать.
Умножение и деление
Для обозначения операции умножения используется символ * (звездочка). Эта операция выполняется очевидным образом — результат вычисляется путем перемножения обоих операндов.
Вот пример использования операции умножения:
int first = 2;
int second = 3;
int result = first * second * 2;
Как видите, в операции умножения могут быть задействованы числовые переменные и числовые литералы.
Хотя смысл операции умножения и способ применения соответствующего оператора достаточно понятен, здесь есть свои подводные камни.
Попробуем выполнить следующую программу:
using System;
namespace MathOperators2
{
class Math0peratorsApp2
{
static void Main(string[] args)
{
int x, y, z;
x = 2;
y = x * 2 ;
z = x * y * 10;
System.Console.WriteLine(" x = {0}, у = {1}, z = {2}",
x, y, z);
System.Console.WriteLine(" 127 * 0 = {0}" , 127 * 0);
uint uX = 400000000;
System.Console.WriteLine(" 400000000 * 3 = {0}", uX * 3);
uint uXl = 4000000000;
System.Console.WriteLine("4000000000 * 3 = {0}", uXl * 3);
System.Console.ReadLine();
}
}
}
На экране монитора увидим:
В результате умножения числа 400 000 000 на 3 получилось, как мы и ожидали, значение 1 200 000 000. Однако та же самая операция над числом 4 000 000 000 привела к неправильному результату — вместо 12 000 000 000 у нас получилось 3 410 065 408!
Где же ошибка? Ошибка была допущена при выборе типа данных для переменной uX1. Если вы посмотрите на соответствующую таблицу, то увидите, что в переменной типа uint можно хранить значения, не превосходящие 4 294 967 295. Мы же попытались записать туда число 12 000 000 000, почти втрое превосходящее максимально допустимое. В результате произошло переполнение, и старшие разряды результата умножения оказались потеряны.
Чтоб исправить ошибку, нужно заменить тип uint на ulong, специально предназначенный для хранения больших чисел. После этого операция умножения будет выполнена правильно.
Для обозначения операции деления используется слеш ( / ). В операции участвуют два операнда — делимое и делитель:
int х = 4;
int у = 2;
int z = х / у;
Если делятся целые числа, то остаток от деления теряется. В результате деления чисел с плавающей точкой получается число с плавающей точкой. Если один из операндов является целым числом, а другой — числом с плавающей точкой, то в результате получится число с плавающей точкой.
Как и во многих других языках программирования, деление на нуль не допускается. Проиллюстрируем сказанное на примере:
using System;
namespace Math0peratorsApp3
{
class MathOperatorsApp3
{
static void Main(string[] args)
{
System.Console.WriteLine("6 / 3 = {0}", 6 / 3 );
System.Console.WriteLine("6 / 4 = {0}", 6 / 4 );
System.Console.WriteLine("6.0 / 4.0 = {0}", 6.0 / 4.0);
System.Console.WriteLine("6.0 / 4 = {0}", 6.0 / 4 );
System.Console.ReadLine();
}
}
}
Результат выполнения этой программы:
Обратите внимание, что при целочисленном делении остаток действительно теряется. Об этом нам говорит вторая строка с результатами деления числа 6 на число 4.
Третья строка представляет результат деления таких же чисел, но в формате с плавающей запятой. Как видите, теперь в результате вычислений мы получили ожидаемый результат — значение 1,5.
Последняя строка отражает результат деления числа с плавающей точкой на целое число. Из нее видно, что результат такого деления представляется в виде числа с плавающей запятой.
Ошибки при делении возникает, если в данную программу добавить строки вида:
int х = 5 ;
int у = 0;
int z = х / у;
В зависимости от версии операционной системы и Visual Studio вид сообщения может несколько меняться, но примерно выглядит оно так:
Из него можно сделать вывод, что в работе программы возникло исключительное состояние, которое привело к ее аварийному завершению, и произошло это в результате деления на нуль.