Разность в си шарп

— и -= операторы — вычитание (минус)

Операторы — и -= поддерживаются встроенными целыми числовыми типами и числовыми типами с плавающей запятой, а также типами делегатов.

Удаление делегатов

Для операндов одного и того же типа delegate оператор — возвращает экземпляр делегата, который вычисляется следующим образом:

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

Action a = () => Console.Write("a"); Action b = () => Console.Write("b"); var abbaab = a + b + b + a + a + b; abbaab(); // output: abbaab Console.WriteLine(); var ab = a + b; var abba = abbaab - ab; abba(); // output: abba Console.WriteLine(); var nihil = abbaab - abbaab; Console.WriteLine(nihil is null); // output: True 

Action a = () => Console.Write("a"); Action b = () => Console.Write("b"); var abbaab = a + b + b + a + a + b; var aba = a + b + a; var first = abbaab - aba; first(); // output: abbaab Console.WriteLine(); Console.WriteLine(object.ReferenceEquals(abbaab, first)); // output: True Action a2 = () => Console.Write("a"); var changed = aba - a; changed(); // output: ab Console.WriteLine(); var unchanged = aba - a2; unchanged(); // output: aba Console.WriteLine(); Console.WriteLine(object.ReferenceEquals(aba, unchanged)); // output: True 

Action a = () => Console.Write("a"); var nothing = null - a; Console.WriteLine(nothing is null); // output: True var first = a - null; a(); // output: a Console.WriteLine(); Console.WriteLine(object.ReferenceEquals(first, a)); // output: True 

Объединить делегаты можно с помощью оператора + .

См. дополнительные сведения о типах делегатов.

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

Выражение, использующее оператор -= , такое как

за исключением того, что x вычисляется только один раз.

В следующем примере иллюстрируется использование оператора -= .

int i = 5; i -= 9; Console.WriteLine(i); // Output: -4 Action a = () => Console.Write("a"); Action b = () => Console.Write("b"); var printer = a + b + a; printer(); // output: aba Console.WriteLine(); printer -= a; printer(); // output: ab 

Можно также использовать оператор -= , который позволяет указать метод обработчика событий для удаления при отмене подписки на событие. Дополнительные сведения см. в разделе Практическое руководство. Подписка и отмена подписки на события.

Возможность перегрузки оператора

Определяемый пользователем тип может перегружать оператор — . При перегрузке бинарного оператора — неявно перегружается и соответствующий оператор -= . Определяемый пользователем тип не может явно перегружать -= оператор.

Спецификация языка C#

См. также раздел

Источник

Разность в си шарп

В C# используется большинство операций, которые применяются и в других языках программирования. Операции представляют определенные действия над операндами — участниками операции. В качестве операнда может выступать переменной или какое-либо значение (например, число). Операции бывают унарными (выполняются над одним операндом), бинарными — над двумя операндами и тернарными — выполняются над тремя операндами. Рассмотрим все виды операций.

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

+ Операция сложения двух чисел:

int x = 10; int z = x + 12; // 22

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 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=");

Ассоциативность операторов

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

Стоит нам трактовать это выражение как (10 / 5) * 2 или как 10 / (5 * 2) ? Ведь в зависимости от трактовки мы получим разные результаты.

Когда операции имеют один и тот же приоритет, порядок вычисления определяется ассоциативностью операторов. В зависимости от ассоциативности есть два типа операторов:

• Левоассоциативные операторы, которые выполняются слева направо
• Правоассоциативные операторы, которые выполняются справа налево

Все арифметические операторы являются левоассоциативными, то есть выполняются слева направо. Поэтому выражение 10 / 5 * 2 необходимо трактовать как (10 / 5) * 2 , то есть результатом будет 4.

Источник

Операторы и выражения 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#:

См. также

Источник