Операторы и выражения C# (справочник по C#)
C# предоставляет ряд операторов. Многие из них поддерживаются встроенными типами и позволяют выполнять базовые операции со значениями этих типов. В число этих операторов входят следующие группы:
- Арифметические операторы, выполняющие арифметические операции с числовыми операндами.
- Операторы сравнения, сравнивающие числовые операнды.
- Логические операторы, выполняющие логические операции с операндами bool .
- Битовые операторы и операторы сдвига выполняют битовые операции или операции сдвига с операндами целочисленных типов.
- Операторы равенства проверяют равенство или неравенство своих операндов.
Как правило, можно выполнить перегрузку этих операторов, то есть указать поведение оператора для операндов определяемого пользователем типа.
Простейшими выражениями C# являются литералы (например, целые и реальные числа) и имена переменных. Их можно объединить в сложные выражения с помощью операторов. Приоритет и ассоциативность операторов определяют порядок выполнения операций в выражении. Порядок вычисления, определяемый приоритетом и ассоциативностью операторов, можно изменить с помощью скобок.
В следующем коде примеры выражений находятся в правой части назначений:
int a, b, c; a = 7; b = a; c = b++; b = a + b * c; c = a >= 100 ? b : c / 10; a = (int)Math.Sqrt(b * b + c * c); string s = "String literal"; char l = s[s.Length - 1]; var numbers = new List(new[] < 1, 2, 3 >); b = numbers.FindLast(n => n > 1); Как правило, выражение выдает результат и может быть заключено в другое выражение. Вызов метода void является примером выражения, которое дает результат. Его можно использовать только в качестве оператора, как показано в следующем примере:
Console.WriteLine("Hello, world!"); Ниже приведены некоторые другие виды выражений, доступные в C#:
-
Выражения интерполированных строк, которые предоставляют удобный синтаксис для создания форматированных строк:
var r = 2.3; var message = $"The area of a circle with radius is ."; Console.WriteLine(message); // Output: // The area of a circle with radius 2.3 is 16.619. int[] numbers = < 2, 3, 4, 5 >; var maximumSquare = numbers.Max(x => x * x); Console.WriteLine(maximumSquare); // Output: // 25 var scores = new[] < 90, 97, 78, 68, 85 >; IEnumerable highScoresQuery = from score in scores where score > 80 orderby score descending select score; Console.WriteLine(string.Join(" ", highScoresQuery)); // Output: // 97 90 85 Определение тела выражения можно использовать, чтобы предоставить краткое определение для метода, конструктора, свойства, индексатора или метода завершения.
Приоритет операторов
В выражении с несколькими операторами операторы с более высоким приоритетом оцениваются до операторов с более низким приоритетом. В следующем примере умножение выполняется сначала, так как оно имеет более высокий приоритет, чем сложение:
var a = 2 + 2 * 2; Console.WriteLine(a); // output: 6 Используйте скобки, чтобы изменить порядок вычисления, накладываемый приоритетом операторов:
var a = (2 + 2) * 2; Console.WriteLine(a); // output: 8 В следующей таблице перечислены операторы C# в порядке убывания приоритета. Операторы в каждой строке имеют одинаковый приоритет.
| Операторы | Категория или имя |
|---|---|
| x.y, f(x), a[i], x?.y , x?[y] x++, x—, x!, new, typeof, checked, unchecked, default, nameof, delegate, sizeof, stackalloc, x-y> | Основной |
| +x, -x, !x, ~x, ++x, —x, ^x, ^x, (T)x, await, &x, *x, true и false | Унарный |
| x..y | Диапазон |
| switch, with | Выражения switch и with |
| x * y, x / y, x % y | Мультипликативный |
| x + y, x – y | Аддитивный |
| x > y | Сдвиг |
| x < y, x y, x >= y, is, as | Тестирование типов и относительный |
| x == y, x != y | Равенство |
| x & y | Логическое И или побитовое логическое И |
| x ^ y | Логическое исключающее ИЛИ или побитовое логическое исключающее ИЛИ |
| x | y | Логическое ИЛИ или побитовое логическое ИЛИ |
| x && y | Условное И |
| x || Y | Условное ИЛИ |
| X?? да | Оператор объединения с NULL |
| C? t : f | Условный оператор |
| x = y, x += y, x -= y, x *= y, x /= y, x %= y, x = y, x &|= y, x ^= y, x >= y, x ?? = y, => | Назначение и объявление лямбда-выражений |
Ассоциативность операторов
Если операторы имеют одинаковый приоритет, порядок их выполнения определяется ассоциативностью операторов:
- Операторы с левой ассоциативностью вычисляются слева направо. За исключением операторов присваивания и оператора объединения со значением NULL, все бинарные операторы имеют левую ассоциативность. Например, выражение a + b — c вычисляется как (a + b) — c .
- Операторы с правой ассоциативностью вычисляются справа налево. Операторы присваивания, операторы объединения null, лямбда-выражения и условные операторы ?: являются правильными ассоциативными. Например, выражение x = y = z вычисляется как x = (y = z) .
Используйте скобки, чтобы изменить порядок вычисления, накладываемый ассоциативностью операторов:
int a = 13 / 5 / 2; int b = 13 / (5 / 2); Console.WriteLine($"a = , b = "); // output: a = 1, b = 6 Вычисление операнда
Не связанные с приоритетом и ассоциативностью операторов операнды в выражении вычисляются слева направо. В следующих примерах иллюстрируется порядок вычисления операторов и операндов:
| Выражение | Порядок вычислений |
|---|---|
| a + b | a, b, + |
| a + b * c | a, b, c, *, + |
| a / b + c * d | a, b, /, c, d, *, + |
| a / (b + c) * d | a, b, c, +, /, d, * |
Как правило, оцениваются все операнды операторов. Однако некоторые операторы оценивают операнды условно. То есть значение крайнего левого операнда такого оператора определяет, следует ли оценивать другие операнды. Эти операторы являются условными логическими операторами И ( && ) и ИЛИ ( || ) , операторами объединения со значением NULL ?? и ??= , условными операторами со значением NULL ?. и ?[] и условным оператором ?: . Дополнительные сведения см. в описании каждого оператора.
Спецификация языка C#
Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:
См. также
- справочник по C#
- Перегрузка операторов
- Деревья выражений
Что делает операция в си шарп
В C# используется большинство операций, которые применяются и в других языках программирования. Операции представляют определенные действия над операндами — участниками операции. В качестве операнда может выступать переменной или какое-либо значение (например, число). Операции бывают унарными (выполняются над одним операндом), бинарными — над двумя операндами и тернарными — выполняются над тремя операндами. Рассмотрим все виды операций.
Бинарные арифметические операции:
-
+ Операция сложения двух чисел:
int x = 10; int z = x + 12; // 22
int x = 10; int z = x - 6; // 4
int x = 10; int z = x * 5; // 50
int x = 10; int z = x / 5; // 2 double a = 10; double b = 3; double c = a / b; // 3.33333333
При делении стоит учитывать, что если оба операнда представляют целые числа, то результат также будет округляться до целого числа:
double z = 10 / 4; //результат равен 2
Несмотря на то, что результат операции в итоге помещается в переменную типа double, которая позволяет сохранить дробную часть, но в самой операции участвуют два литерала, которые по умолчанию рассматриваются как объекты int, то есть целые числа, и результат то же будет целочисленный. Для выхода из этой ситуации необходимо определять литералы или переменные, участвующие в операции, именно как типы double или float:
double z = 10.0 / 4.0; //результат равен 2.5
double x = 10.0; double z = x % 4.0; //результат равен 2
Также есть ряд унарных операций, в которых принимает участие один операнд:
-
++ Операция инкремента Инкремент бывает префиксным: ++x — сначала значение переменной x увеличивается на 1, а потом ее значение возвращается в качестве результата операции.
И также существует постфиксный инкремент: x++ — сначала значение переменной x возвращается в качестве результата операции, а затем к нему прибавляется 1.
int x1 = 5; int z1 = ++x1; // z1=6; x1=6 Console.WriteLine($" - "); int x2 = 5; int z2 = x2++; // z2=5; x2=6 Console.WriteLine($" - ");
int x1 = 5; int z1 = --x1; // z1=4; x1=4 Console.WriteLine($" - "); int x2 = 5; int z2 = x2--; // z2=5; x2=4 Console.WriteLine($" - ");
При выполнении сразу нескольких арифметических операций следует учитывать порядок их выполнения. Приоритет операций от наивысшего к низшему:
- Инкремент, декремент
- Умножение, деление, получение остатка
- Сложение, вычитание
Для изменения порядка следования операций применяются скобки.
Рассмотрим набор операций:
int a = 3; int b = 5; int c = 40; int d = c---b*a; // a=3 b=5 c=39 d=25 Console.WriteLine($"a= b= c= d=");
Здесь мы имеем дело с тремя операциями: декремент, вычитание и умножение. Сначала выполняется декремент переменной c, затем умножение b*a, и в конце вычитание. То есть фактически набор операций выглядел так:
int d = (c--)-(b*a);
Но с помощью скобок мы могли бы изменить порядок операций, например, следующим образом:
int a = 3; int b = 5; int c = 40; int d = (c-(--b))*a; // a=3 b=4 c=40 d=108 Console.WriteLine($"a= b= c= d=");
Ассоциативность операторов
Как выше было отмечено, операции умножения и деления имеют один и тот же приоритет, но какой тогда результат будет в выражении:
int x = 10 / 5 * 2;
Стоит нам трактовать это выражение как (10 / 5) * 2 или как 10 / (5 * 2) ? Ведь в зависимости от трактовки мы получим разные результаты.
Когда операции имеют один и тот же приоритет, порядок вычисления определяется ассоциативностью операторов. В зависимости от ассоциативности есть два типа операторов:
- Левоассоциативные операторы, которые выполняются слева направо
- Правоассоциативные операторы, которые выполняются справа налево
Все арифметические операторы являются левоассоциативными, то есть выполняются слева направо. Поэтому выражение 10 / 5 * 2 необходимо трактовать как (10 / 5) * 2 , то есть результатом будет 4.
Арифметические операторы (справочник по C#)
Следующие операторы выполняют арифметические операции с операндами числовых типов:
- унарные — ++ (приращение), — (уменьшение), + (плюс) и — (минус);
- бинарные — * (умножение), / (деление), % (остаток от деления), + (сложение) и — (вычитание).
Эти операторы поддерживаются всеми целочисленными типами и типами с плавающей запятой.
В случае целочисленных типов эти операторы (за исключением операторов ++ и — ) определяются для типов int , uint , long и ulong . Если операнды принадлежат к другим целочисленным типам ( sbyte , byte , short , ushort или char ), их значения преобразуются в тип int , который также является типом результата операции. Если операнды принадлежат к разным целочисленным типам или типам с плавающей запятой, их значения преобразуются в ближайший содержащий тип, если такой тип существует. Дополнительные сведения см. в разделе Числовые повышения уровня в статье Спецификации языка C#. Операторы ++ и — определяются для всех целочисленных числовых типов и числовых типов с плавающей запятой, а также типа char. Тип результата выражения сложного назначения является типом левого операнда.
Оператор инкремента ++
Оператор инкремента ++ увеличивает операнд на 1. Операндом должна быть переменная, свойство или индексатор.
Оператор инкремента поддерживается в двух формах: постфиксный оператор инкремента ( x++ ) и префиксный оператор инкремента ( ++x ).
Постфиксный оператор приращения
Результатом x++ является значение x перед выполнением операции, как показано в следующем примере:
int i = 3; Console.WriteLine(i); // output: 3 Console.WriteLine(i++); // output: 3 Console.WriteLine(i); // output: 4 Префиксный оператор инкремента
Результатом ++x является значение x после выполнения операции, как показано в следующем примере:
double a = 1.5; Console.WriteLine(a); // output: 1.5 Console.WriteLine(++a); // output: 2.5 Console.WriteLine(a); // output: 2.5 Оператор декремента —
Унарный оператор декремента — уменьшает операнд на 1. Операндом должна быть переменная, свойство или индексатор.
Оператор декремента поддерживается в двух формах: постфиксный оператор декремента ( x— ) и префиксный оператор декремента ( —x ).
Постфиксный оператор уменьшения
Результатом x— является значение x перед выполнением операции, как показано в следующем примере:
int i = 3; Console.WriteLine(i); // output: 3 Console.WriteLine(i--); // output: 3 Console.WriteLine(i); // output: 2 Префиксный оператор декремента
Результатом —x является значение x после выполнения операции, как показано в следующем примере:
double a = 1.5; Console.WriteLine(a); // output: 1.5 Console.WriteLine(--a); // output: 0.5 Console.WriteLine(a); // output: 0.5 Операторы унарного плюса и минуса
Унарный оператор + возвращает значение полученного операнда. Унарный оператор — изменяет знак операнда на противоположный.
Console.WriteLine(+4); // output: 4 Console.WriteLine(-4); // output: -4 Console.WriteLine(-(-4)); // output: 4 uint a = 5; var b = -a; Console.WriteLine(b); // output: -5 Console.WriteLine(b.GetType()); // output: System.Int64 Console.WriteLine(-double.NaN); // output: NaN Тип ulong не поддерживает унарный оператор — .
Оператор умножения *
Оператор умножения * вычисляет произведение операндов:
Console.WriteLine(5 * 2); // output: 10 Console.WriteLine(0.5 * 2.5); // output: 1.25 Console.WriteLine(0.1m * 23.4m); // output: 2.34 Оператор деления /
Оператор деления / делит левый операнд на правый.
Деление целых чисел
Для операндов цельночисленных типов результат оператора / является целочисленным типом, который равен частному двух операндов, округленному в сторону нуля:
Console.WriteLine(13 / 5); // output: 2 Console.WriteLine(-13 / 5); // output: -2 Console.WriteLine(13 / -5); // output: -2 Console.WriteLine(-13 / -5); // output: 2 Чтобы получить частное двух операндов в виде числа с плавающей запятой, используйте тип float , double или decimal :
Console.WriteLine(13 / 5.0); // output: 2.6 int a = 13; int b = 5; Console.WriteLine((double)a / b); // output: 2.6 Деление чисел с плавающей запятой
Для типов float , double и decimal результатом оператора / является частное двух операндов:
Console.WriteLine(16.8f / 4.1f); // output: 4.097561 Console.WriteLine(16.8d / 4.1d); // output: 4.09756097560976 Console.WriteLine(16.8m / 4.1m); // output: 4.0975609756097560975609756098 Если один из операндов — это decimal , второй операнд не может быть ни float , ни double , так как ни float , ни double не преобразуется неявно в тип decimal . Необходимо явным образом преобразовать операнд float или double в тип decimal . Дополнительные сведения о числовых преобразованиях см. в разделе Встроенные числовые преобразования.
Оператор остатка %
Оператор остатка % вычисляет остаток от деления левого операнда на правый.
Целочисленный остаток
Для целочисленных операндов результатом a % b является значение, произведенное a — (a / b) * b . Знак ненулевого остатка такой же, как и у левого операнда, как показано в следующем примере:
Console.WriteLine(5 % 4); // output: 1 Console.WriteLine(5 % -4); // output: 1 Console.WriteLine(-5 % 4); // output: -1 Console.WriteLine(-5 % -4); // output: -1 Используйте метод Math.DivRem для вычисления результатов как целочисленного деления, так и определения остатка.
Остаток с плавающей запятой
Для операндов типа float и double результатом x % y для конечных x и y будет значение z , так что:
- знак z , если отлично от нуля, совпадает со знаком x ;
- абсолютное значение z является значением, произведенным |x| — n * |y| , где n — это наибольшее возможное целое число, которое меньше или равно |x| / |y| , а |x| и |y| являются абсолютными значениями x и y , соответственно.
Этот метод вычисления остатка аналогичен тому, который использовался для целочисленных операндов, но отличается от спецификации IEEE 754. Если вам нужна операция вычисления остатка, которая соответствует спецификации IEEE 754, используйте метод Math.IEEERemainder.
Сведения о поведение оператора % в случае неконечных операндов см. в разделе Оператор остаткаспецификации языка C#.
Для операндов decimal оператор остатка % эквивалентен оператору остатка типа System.Decimal.
В следующем примере показано поведение оператора остатка для операндов с плавающей запятой:
Console.WriteLine(-5.2f % 2.0f); // output: -1.2 Console.WriteLine(5.9 % 3.1); // output: 2.8 Console.WriteLine(5.9m % 3.1m); // output: 2.8 Оператор сложения +
Оператор сложения + вычисляет сумму своих операндов:
Console.WriteLine(5 + 4); // output: 9 Console.WriteLine(5 + 4.3); // output: 9.3 Console.WriteLine(5.1m + 4.2m); // output: 9.3 Кроме того, оператор + можно использовать для объединения строк и делегатов. Дополнительные сведения см. в статье Операторы + и += .
Оператор вычитания —
Оператор вычитания — вычитает правый операнд из левого:
Console.WriteLine(47 - 3); // output: 44 Console.WriteLine(5 - 4.3); // output: 0.7 Console.WriteLine(7.5m - 2.3m); // output: 5.2 Кроме того, оператор — можно использовать для удаления делегатов. Дополнительные сведения см. в статье Операторы — и -= .
Составное присваивание
Для бинарного оператора op выражение составного присваивания в форме
x op= y x = x op y за исключением того, что x вычисляется только один раз.
Следующий пример иллюстрирует использование составного присваивания с арифметическими операторами:
int a = 5; a += 9; Console.WriteLine(a); // output: 14 a -= 4; Console.WriteLine(a); // output: 10 a *= 2; Console.WriteLine(a); // output: 20 a /= 4; Console.WriteLine(a); // output: 5 a %= 3; Console.WriteLine(a); // output: 2 Из-за восходящих приведений результат операции op может быть невозможно неявно преобразовать в тип T из x . В этом случае, если op является предопределенным оператором, и результат операции является явно преобразуемым в тип T x , выражение составного присваивания формы x op= y эквивалентно x = (T)(x op y) , за исключением того, что x вычисляется только один раз. В следующем примере продемонстрировано такое поведение.
byte a = 200; byte b = 100; var c = a + b; Console.WriteLine(c.GetType()); // output: System.Int32 Console.WriteLine(c); // output: 300 a += b; Console.WriteLine(a); // output: 44 В предыдущем примере значение 44 является результатом преобразования значения 300 в byte тип .
Вы также можете использовать операторы += и -= для подписки и отмены подписки на события соответственно. Дополнительные сведения см. в разделе Практическое руководство. Подписка и отмена подписки на события.
Приоритет и ассоциативность операторов
В следующем списке перечислены арифметические операторы в порядке убывания приоритета:
- Постфиксный инкремент x++ и декремент x—
- Префиксный инкремент ++x и декремент —x , унарные операторы + и —
- Мультипликативные операторы * , / , и %
- Аддитивные операторы + и —
Бинарные арифметические операторы имеют левую ассоциативность. То есть операторы с одинаковым приоритетом вычисляются в направлении слева направо.
Порядок вычисления, определяемый приоритетом и ассоциативностью операторов, можно изменить с помощью скобок ( () ).
Console.WriteLine(2 + 2 * 2); // output: 6 Console.WriteLine((2 + 2) * 2); // output: 8 Console.WriteLine(9 / 5 / 2); // output: 0 Console.WriteLine(9 / (5 / 2)); // output: 4 Полный список операторов C#, упорядоченный по уровню приоритета, можно найти в разделе Приоритет операторов статьи Операторы C#.
Арифметическое переполнение и деление на нуль
Если результат арифметической операции выходит за пределы диапазона возможных конечных значений соответствующего числового типа, поведение арифметического оператора зависит от типа его операндов.
Целочисленное арифметическое переполнение
Деление целого числа на ноль всегда вызывает исключение DivideByZeroException.
В случае целочисленного арифметического переполнения итоговое поведение определяется проверяемым или непроверяемым контекстом проверки переполнения:
- Если в проверяемом контексте переполнение возникает в константном выражении, происходит ошибка времени компиляции. В противном случае, если операция производится во время выполнения, возникает исключение OverflowException.
- В непроверяемом контексте результат усекается путем удаления старших разрядов, которые не помещаются в целевой тип данных.
Вместе с проверяемыми и непроверяемыми операторами можно использовать операторы checked и unchecked , чтобы управлять контекстом проверки переполнения, в котором вычисляется выражение:
int a = int.MaxValue; int b = 3; Console.WriteLine(unchecked(a + b)); // output: -2147483646 try < int d = checked(a + b); >catch(OverflowException) < Console.WriteLine($"Overflow occurred when adding to ."); > По умолчанию арифметические операции выполняются в непроверяемом контексте.
Арифметическое переполнение с плавающей запятой
Арифметические операции с типами float и double никогда не вызывают исключение. Результатом арифметических операций с этими типами может быть одно из специальных значений, представляющих бесконечность и объект, не являющийся числовым:
double a = 1.0 / 0.0; Console.WriteLine(a); // output: Infinity Console.WriteLine(double.IsInfinity(a)); // output: True Console.WriteLine(double.MaxValue + double.MaxValue); // output: Infinity double b = 0.0 / 0.0; Console.WriteLine(b); // output: NaN Console.WriteLine(double.IsNaN(b)); // output: True Для операндов типа decimal арифметическое переполнение всегда выдает исключение OverflowException, а деление на нуль — DivideByZeroException.
Ошибки округления
Из-за общих ограничений, касающихся представления вещественных чисел в форме с плавающей запятой и арифметических операций с плавающей запятой, при вычислениях с использованием типов с плавающей запятой могут возникать ошибки округления. То есть полученный результат выражения может отличаться от ожидаемого математического результата. В следующем примере показано несколько таких случаев:
Console.WriteLine(.41f % .2f); // output: 0.00999999 double a = 0.1; double b = 3 * a; Console.WriteLine(b == 0.3); // output: False Console.WriteLine(b - 0.3); // output: 5.55111512312578E-17 decimal c = 1 / 3.0m; decimal d = 3 * c; Console.WriteLine(d == 1.0m); // output: False Console.WriteLine(d); // output: 0.9999999999999999999999999999 См. заметки в справочной документации по System.Double, System.Single и System.Decimal.
Возможность перегрузки оператора
Определяемый пользователем тип может перегружать унарные ( ++ , — , + и — ) и бинарные ( * , / , % , + и — ) арифметические операторы. При перегрузке бинарного оператора соответствующий оператор составного присваивания также неявно перегружается. Явная перегрузка составного оператора присваивания для пользовательского типа невозможна.
Проверенные операторы, определяемые пользователем
Начиная с C# 11 при перегрузке арифметического оператора можно использовать ключевое слово checked , чтобы определить проверенную версию этого оператора. Следующий пример показывает, как это сделать:
public record struct Point(int X, int Y) < public static Point operator checked +(Point left, Point right) < checked < return new Point(left.X + right.X, left.Y + right.Y); >> public static Point operator +(Point left, Point right) < return new Point(left.X + right.X, left.Y + right.Y); >> При определении проверенного оператора следует также определить соответствующий оператор без модификатора checked . Проверенный оператор вызывается в проверенном контексте. Оператор без модификатора checked вызывается в непроверенном контексте. Если указать только оператора без модификатора checked , он будет вызываться как в контексте checked , так и в unchecked .
При определении обеих версий оператора их поведение будет различаться только в том случае, если результат операции слишком велик, чтобы представить его тип следующим образом:
- Проверенный оператор вызывает OverflowException.
- Оператор без модификатора checked возвращает экземпляр, который представляет усеченный результат.
Сведения о разнице в поведении встроенных арифметических операторов см. в разделе Арифметическое переполнение и деление на ноль.
Модификатор checked можно использовать только при перегрузке следующих операторов:
- Унарные операторы ++ , — и —
- Бинарные операторы * , / , + и —
- Операторы явного преобразования
Контекст проверки переполнения в теле проверенного оператора не изменяется при наличии модификатора checked . Контекст по умолчанию определяется значением параметра компилятора CheckForOverflowUnderflow. С помощью операторов checked и unchecked можно явно указать контекст проверки переполнения, как показано в примере в начале этого раздела.
Спецификация языка C#
Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:
- Постфиксные операторы инкремента и декремента
- Префиксные операторы инкремента и декремента
- Оператор унарного плюса
- Оператор унарного минуса
- Оператор умножения
- Оператор деления
- Оператор остатка
- Оператор сложения
- Оператор вычитания
- Составное присваивание
- Операторы checked и unchecked
- Восходящие приведения числовых типов
См. также раздел
- справочник по C#
- Операторы и выражения C#
- System.Math
- System.MathF
- Числовые значения в .NET
Совместная работа с нами на GitHub
Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.
The .NET documentation is open source. Provide feedback here.
Обратная связь
Отправить и просмотреть отзыв по
Арифметические операции
Язык C# поддерживает множество арифметических операторов, которые позволяют выполнять математические действия над операндами, и возвращают результат в виде числового значения. Операнды – это числовые значения: литералы, константы, переменные, которые принимают участие в операции.
В зависимости от количества операндов, которые принимает оператор, операции делятся на:
- унарные – применяются к одному операнду;
- бинарные – к двум операндам.
Унарные арифметические операторы
Оператор +
Унарный плюс – возвращает то самое значение, которое было ему передано в качестве аргумента.
int number1 = +345; //345 int number2 = +number1; //345 Оператор —
Унарный минус – используется для изменения знака числа.
long x = -123; long y = -x; //123 Инкремент ++
Инкремент применяется для увеличения числового значения на единицу. В C# существуют два инкремента: префиксный и постфиксный.
Префиксный инкремент увеличивает числовое значение операнда на единицу и возвращает вычисленное значение.
byte a = 5; byte b = ++a; // b = 6; Постфиксный инкремент сперва возвращает значение операнда, а после этого увеличивает его значение на единицу.
byte c = 5; byte d = c++; // d = 5; c = 6; Декремент —
Декремент используется для уменьшения значения на единицу.
Префиксный декремент уменьшает числовое значение операнда на единицу и возвращает результат.
byte u = 9; byte v = --u; // v = 8; Постфиксный декремент сперва возвращает значение, а потом уменьшает его на единицу.
byte y = 7; byte z = y--; // z = 7; y = 6; В большей части программ можно встретить постфиксные декремент и инкремент (i—, i++), хотя для их выполнения используется больше ресурсов компьютера. Поэтому, при возможности, используйте префиксные операторы(++i, —i), это дает возможность улучшить производительность выполнения программы.
Бинарные арифметические операции
Оператор сложения +
Бинарный плюс – возвращает сумму значений операндов.
int x = 34 + 5; //39 int y = x + 2 + 1; //42 Оператор вычитания —
Бинарный минус – используется для получения разности двух чисел.
var k = 22 - 10; //12 var g = k - 9; //3 Оператор деления /
Для целых чисел возвращает результат округленный результат деления, остаток от деления отбрасывается.
int f = 32 / 10; //3 int h = f / 2; //1 Для вещественных чисел – результат арифметического деления.
float t = 36F / 10; //3.6 float r = t / 2; //1.8 Если оба операнда являются целыми числами, то результатом выполнения операции деления будет целое число.
double j = 33 / 5; //5 Для решения этой проблемы, необходимо явно указать тип данных, хотя бы одного из значений, с помощью литерального суффикса, или добавив в конец числа “.0”:
double j = 33d / 5; //6.6 double h = 47 / 4.0; //11.75 Остаток от деления %
Оператор для получения остатка от деления двух операндов.
int m = 98 % 9; //8 var n = m % 5; //3 Порядок выполнения арифметических операций
При выполнении нескольких операций в одном выражении, нужно учитывать их приоритет. Наивысший приоритет имеют унарные операции, за ними следуют мультипликативные(умножение, деление и взятие остатка), после них выполняются аддитивные(суммирование и вычитание) операции.
int p = 12 + 9 * 3 - 4 / 2; //37 В данном примере, сперва вычисляется результат умножения, потом деление, а после этого, слева на право суммирование и вычитание.
Для того, чтобы изменить порядок выполнения операций, можно пользоваться скобками.
Ассоциативность операций
Ассоциативность – это свойство операций, которое позволяет определить последовательность их выполнения при равном приоритете.
Существуют два типа ассоциативности:
- левоассоциативные операции – выполняются в порядке слева направо;
- правоассоциативные – справа налево;
Большинство операторов языка C# относятся к первому типу. Во второй входят префиксные инкремент и декремент.
Исходя из этого, выражение b = 45 * 12 — 3 / 4 воспринимается компилятором как b = (45 * 12) — (3 / 4).
При выполнении сложных математических расчетов, разбивайте длинные выражения на несколько простых, используйте скобки, если приоритет выполнения операций не очевиден. Это улучшит читабельность кода программы и позволит избежать непонятных ситуаций.