Арифметические операторы в C#

Операторы в C# — это символы, которые используются для выполнения операций над операндами. Например, рассмотрим выражение 2 + 3 = 5. Здесь 2 и 3 — операнды, а + и = — операторы. Таким образом, операторы в C# используются для работы с переменными и значениями в программе. В C# есть различные группы операторов – арифметические, логические и т.д. В этой части мы будем подробно разбираться с арифметическими операторами. Арифметические операторы в C#, как следует из их названия, применяются для выполнения каких-либо арифметических операций.

Арифметические операторы в C#

Арифметические операторы в C# можно классифицировать следующим образом:

Арифметические операторы в C# подразделяются на две большие группы – унарные и бинарные операторы.

Унарные операторы – это операторы, которые применяются к одному операнду.

Бинарный оператор – это оператор, который применяется к двум операндам, которые называются левый операнд и правый операнд (по их положению относительно оператора. Например, 2 + 3: здесь 2 – это левый операнд, 3 – правый операнд, а + – оператор сложения.

Большинство из этих операторов нам известны ещё со школьной скамью, однако, не лишним будет напомнить об их работе в контексте программирования на языке C#.

Бинарные арифметические операторы

Оператор присваивания (=)

Первое, что сводит с ума новичка в программировании – это оператор присваивания. Этот оператор похож на математическое “равно”, но читается как “присвоить”. Например, вот такая инструкция:

a = a + 5;

для человека со знанием школьной математики выглядит абсурдно, а программисту – в самый раз. Потому что эта инструкция читается так: “присвоить переменной a значение а плюс 5“. То есть, вначале необходимо прибавить к переменной 5, а затем полученное значение будет присвоено переменной.

Операторы сложения (+) и вычитания (-)

Эти операторы работают точно также, как и в обычной математике:

• оператор сложения – складывает левый и правый операнды
• оператор вычитания – вычитает из левого операнда правый операнд

Например,

int a = 10;
int b = 3;
int c = a + b; //13
int d = a - b - c; //-6

Оператор умножения (*)

Как и в математике, оператор умножения выполняет умножение двух операндов. При этом, C# пытается подобрать для результата вычисления наиболее “вместительный” тип данных. Рассмотрим следующий пример:

ushort a = 10; //создали переменную
ushort b = 5; //создали переменную b
ushort c = a * b;

Этот пример не скомпилируется и в Visual Studio мы увидим ошибку:

Что это за “приведение типов” мы узнаем в следующей части, а пока стоит запомнить, что при перемножении двух целых чисел C# пытается подобрать для результата наиболее подходящий тип данных. Тип ushort– это целое число в диапазоне от -32 768 до 32 767. Что будет, если мы перемножим максимальное и минимальное значение из этого диапазона? Мы получим -1073709056. Самый близкий и подходящий для сохранения результата тип – это intс диапазоном значений от -2 147 483 648 до 2 147 483 647. Поэтому правильный вариант вычисления будет вот таким:

ushort a = 10; //создали переменную
ushort b = 5; //создали переменную b
int c = a * b; //50

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

double a = 10; //создали переменную
float b = 5f; //создали переменную b
float c = a * b; //ошибка. Тип должен быть double

Оператор деления (/)

В C# различают деление целых чисел и деление чисел с плавающей точкой (запятой). И здесь стоит запомнить, что

Например,

int a = 10; //создали переменную
int b = 4; //создали переменную b
int c = a / b; //ошибки нет

Математически, результат вычисления 10/4 равен 2,5. Но так как мы делим в C# целые числа, то и ответом будет целое число, то есть 2. Чтобы получить вещественный результат, один или оба операнда должны иметь вещественный тип. Например, чтобы вычисли выражение выше и получить 2,5 мы можем сделать вот так:

double a = 10; //создали переменную
int b = 4; //создали переменную b
double c = a / b; //2,5

Так как один из операндов имеет тип double, то и результат вычисления будет тоже иметь тип double и, в результате, мы получим ответ 2,5.

Ещё одно правило деления чисел в C# звучит следующим образом:

Оператор остатка от деления (%)

В C# также различаются результаты остатка от деления для целых чисел и чисел с плавающей запятой. Для целочисленных операндов результатом a % b является значение полученное из выражения a - (a / b) * b. Знак ненулевого остатка такой же, как и у левого операнда, например:

int a = 10;
int b = -3;
Console.WriteLine(a % b);//1

Остаток от деления чисел с плавающей запятой:

float a = 10.0f;
float b = -3.5f;
Console.WriteLine(a % b);//3

Операторы составного присваивания

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

x [op]= y

где [op]  — какой-либо из рассмотренных выше операторов (+, -, *, /, %). Читается такое выражение в развернутом виде следующим образом:

x = x [op] y

Например,

int a = 10;
a += 5; //15

последняя строка в этом примере в развернутом виде будет выглядеть так:

a = a + 5;

Унарные арифметические операторы в C#

Унарные операторы в C# применяются к одному операнду.

Унарный плюс и унарный минус

Эти операторы действуют также, как и в математике:

• минус – меняет знак числа на противоположный
• плюс – не меняет знак числа

Например,

int a = 10;
a = -a; //-10 (меняем знак операнда) 
a = +a; //-10 (знак операнда остается тот же) 
a = -a; //10 (меняем знак операнда)

Операторы приращения (++) и уменьшения (–)

Оператор приращения (инкремента) ++ увеличивает операнд на 1, а оператор уменьшения (декремента) --, соответственно, уменьшает операнд на 1. Операторы инкремента и декремента в C# поддерживается в двух формах: постфиксной (например, x++) и префиксной (например, ++x).

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

int a = 1;
int b = a++;

Какое значение будет у переменной b? Так как используется постфиксная форма инкремента, то действия будут выполняться в следующей последовательности:

1. переменной b присваивается значение переменной a
2. переменная a увеличивается на 1

Таким образом, в результате мы получим b = 1.

Соответственно, в этом примере:

int a = 1;
int b = ++a;

произойдет всё наоборот, а именно:

1. переменная a увеличивается на единицу
2. значение a присваивается переменной b

в результате b получит значений 2.

Арифметические операторы в C#: приоритет и ассоциативность операторов

Арифметические операторы выполняются в следующем порядке (по убыванию приоритета):

• Постфиксный инкремент x++ и декремент x--
• Префиксный инкремент ++x и декремент --x, унарные операторы + и -
• Мультипликативные операторы *, /, и %
• Аддитивные операторы + и -

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

Для удобства сведем все рассмотренные математические операторы C# в таблицу и расположим их в порядке убывания приоритета.

Таблица математических операторов C# в порядке убывания приоритета

В таблице значение приоритета 1 означает высший приоритет, а 4 — низший.

Подведем итог

Арифметические операторы в C# выполняются в соответствии с их приоритетом. Приоритет по умолчанию меняется с использованием обычных круглых скобок. Арифметические операторы делятся на две группы – унарные (применяются к одному операнду) и бинарные (применяются к двум операндам). Также в C# различают деление целых чисел и деление чисел с плавающей запятой.

Домашнее задание №8

Вычислите результат выражения:

при a = 3; b = 7; c = 10