English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Основной курс C#

Дополнительный курс C#

C# ООП

Операторы в C#

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

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

  • Арифметические операторы

  • Отношение операторы

  • Логические операторы

  • Битовые операторы

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

  • Другие операторы

Этот курс будет подробно объяснять арифметические операторы, сравнительные операторы, логические операторы, битовые операторы, операторы присваивания и другие операторы.

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

В таблице ниже показаны все арифметические операторы, поддерживаемые C#. Предположим, что переменная A Значение равно 10, переменная B Значение равно 20, то есть:

ОператорыОписаниеПример
+Сложение двух операндовA + B будет равняться 30
-Вычитание второго операнда из первогоA - B будет равняться -10
*Умножение двух операндовA * B будет равняться 200
/Деление числителя на знаменательB / A будет равняться 2
%Оператор модуля, оставшаяся часть после деленияB % A будет равняться 0
++Увеличивающий оператор, значение целого увеличивается на 1A++ будет равняться 11
--Уменьшающий оператор, значение целого уменьшается на 1A-- будет равняться 9

Онлайн пример

Смотрите примеры ниже, чтобы понять все доступные арифметические операторы в C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a = 21;
　　　　　　　　　　　　int b = 10;
　　　　　　　　　　　　int c;
　　　　　　　　　　　　c = a + b;
　　　　　　　　　　　　Console.WriteLine("Строка 1 - значение c: {0}", c);
　　　　　　　　　　　　c = a - b;
　　　　　　　　　　　　Console.WriteLine("Строка 2 - значение c равно {0}", c);
　　　　　　　　　　　　c = a * b;
　　　　　　　　　　　　Console.WriteLine("Строка 3 - значение c равно {0}", c);
　　　　　　　　　　　　c = a / b;
　　　　　　　　　　　　Console.WriteLine("Строка 4 - значение c равно {0}", c);
　　　　　　　　　　　　c = a % b;
　　　　　　　　　　　　Console.WriteLine("Строка 5 - значение c равно {0}", c);
　　　　　　　　　　　　// ++a сначала выполняет увеличение, а затем присваивает значение
　　　　　　　　　　　　c = ++a;
　　　　　　　　　　　　Console.WriteLine("Строка 6 - значение c равно {0}", c);
　　　　　　　　　　　　// В этот момент значение a равно 22
　　　　　　　　　　　　// --a сначала выполняет уменьшение, а затем присваивает значение
　　　　　　　　　　　　c = --a;
　　　　　　　　　　　　Console.WriteLine("Строка 7 - значение c равно {0}", c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Когда上面的 код будет скомпилирован и выполнен, он произведет следующие результаты:

Строка 1 - значение c равно 31
Строка 2 - значение c равно 11
Строка 3 - значение c равно 210
Строка 4 - значение c равно 2
Строка 5 - значение c равно 1
Строка 6 - значение c равно 22
Строка 7 - значение c равно 21

  • c = a++: Сначала присваивается значение a c, а затем выполняется увеличение a.

  • c = ++a: Сначала выполняется увеличение a, а затем присваивается значение c.

  • c = a--: Сначала присваивается значение a c, а затем выполняется уменьшение a.

  • c = --a: Сначала выполняется уменьшение a, а затем присваивается значение c.

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a = 1;
　　　　　　　　　　　　int b;
　　　　　　　　　　　　// a++ сначала присваивает значение, а затем выполняет увеличение
　　　　　　　　　　　　b = a++;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　// ++a сначала выполняет увеличение, а затем присваивает значение
　　　　　　　　　　　　a = 1; // Повторно инициализировать a
　　　　　　　　　　　　b = ++a;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　// a-- сначала присваивает значение, а затем выполняет уменьшение
　　　　　　　　　　　　a = 1; // Повторно инициализировать a
　　　　　　　　　　　　b = a--;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　// --a сначала выполняет уменьшение, а затем присваивает значение
　　　　　　　　　　　　a = 1; // Повторно инициализировать a
　　　　　　　　　　　　b = --a;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Выполните вышеуказанный программный код, результат вывода будет:

a = 2
b = 1
a = 2
b = 2
a = 0
b = 1
a = 0
b = 0

Отношение операторы

Таблица显示了 C# поддерживает все отношения операторы. Предположим, переменная A Значение равно 10, переменная B Значение равно 20, то есть:

ОператорыОписаниеПример
==Проверка, равны ли значения двух операндов, если они равны, то условие истинно.(A == B) не истинно.
!=Проверка, равны ли значения двух операндов, если они не равны, то условие истинно.(A != B) истинно.
>Проверка значения левого операнда на больше значения правого операнда, если это так, то условие истинно.(A > B) не истинно.
<Проверка значения левого операнда на меньше значения правого операнда, если это так, то условие истинно.(A < B) истинно.
>=Проверка значения левого операнда на больше или равно значения правого операнда, если это так, то условие истинно.(A >= B) не истинно.
<=Проверка значения левого операнда на меньше или равно значения правого операнда, если это так, то условие истинно.(A <= B) истина.

Онлайн пример

Пожалуйста, посмотрите на следующий пример, чтобы понять все доступные関係ные операторы в C#:

Онлайн пример

using System;
class Program
{
　　static void Main(string[] args)
　　{
　　　　　　int a = 21;
　　　　　　int b = 10;
　　　　　　
　　　　　　if (a == b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("Строка 1 - a равна b");
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Строка 1 - a не равна b");
　　　　　　}
　　　　　　if (a < b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("Строка 2 - a меньше b");
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Строка 2 - a не меньше b");
　　　　　　}
　　　　　　if (a > b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("Строка 3 - a больше b");
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Строка 3 - a не больше b");
　　　　　　}
　　　　　　/* Изменить значения a и b */
　　　　　　a = 5;
　　　　　　b = 20;
　　　　　　if (a <= b)
　　　　　　{
　　　　　　　　　Console.WriteLine("Строка 4 - a меньше или равно b");
　　　　　　}
　　　　　　if (b >= a)
　　　　　　{
　　　　　　　　　Console.WriteLine("Строка 5 - b больше или равно a");
　　　　　　}
　　}
}

Когда上面的 код будет скомпилирован и выполнен, он произведет следующие результаты:

Строка 1 - a не равна b
Строка 2 - a не меньше b
Строка 3 - a больше b
Строка 4 - a меньше или равно b
Строка 5 - b больше или равно a

Логические операторы

Таблица показывает все логические операторы, поддерживаемые C#. Предположим переменную A Для логического значения true, переменная B Для логического значения false:

ОператорыОписаниеПример
&&Назван логическим оператором и. Если оба операнда не равны нулю, то условие истины.(A && B) ложно.
||Назван логическим оператором или. Если один из операндов не равен нулю, то условие истины.(A || B) истина.
!Назван логическим оператором не. Используется для инверсии логического состояния операнда. Если условие истины, то логический оператор не изменит его в ложь.!(A && B) истина.

Онлайн пример

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

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　bool a = true;
　　　　　　　　　　　　bool b = true;
　　　　　　　　　　　
　　　　　　　　　　　　if (a && b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　Console.WriteLine("Строка 1 - Условие истины");
　　　　　　　　　　　　}
　　　　　　　　　　　　if (a || b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Строка 2 - Условие истины");
　　　　　　　　　　　　}
　　　　　　　　　　　　/* Изменить значения a и b */
　　　　　　　　　　　　a = false;
　　　　　　　　　　　　b = true;
　　　　　　　　　　　　if (a && b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Строка 3 - Условие истины");
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Line 3 - условие ложно");
　　　　　　　　　　　　}
　　　　　　　　　　　　if (!(a && b))
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Line 4 - условие истинно");
　　　　　　　　　　　　}
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Когда上面的 код будет скомпилирован и выполнен, он произведет следующие результаты:

Line 1 - условие истинно
Line 2 - условие истинно
Line 3 - условие ложно
Line 4 - условие истинно

Битовые операторы

Битовые операторы действуют на биты и выполняют операции по битам. Истинные таблицы &、| и ^ выглядят следующим образом:

pqp & qp | qp ^ q
00000
01011
11110
10011

Предположим, если A = 60, и B = 13, и они представлены в двоичном формате, они выглядят следующим образом:

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011

В таблице перечислены битовые операторы, поддерживаемые C#. Предположим, что переменная A Если значение 60, переменная B Если значение 13, то:

ОператорыОписаниеПример
&Если бит существует в обоих операндах, битовый оператор AND копирует бит в результат.(A & B) будет равен 12, то есть 0000 1100
|Если бит существует в любом из операндов, битовый оператор OR копирует бит в результат.(A | B) будет равен 61, то есть 0011 1101
^Если бит существует в одном из операндов, но не существует в обоих операндах, битовый оператор XOR копирует бит в результат.(A ^ B) будет равен 49, то есть 0011 0001
~Оператор логического неопределения является унарным оператором, который имеет эффект "переворачивания" бит, то есть 0 становится 1, а 1 становится 0, включая бит знака.(~A) будет равен -61, то есть 1100 0011, это форма кода комплемента положительного двоичного числа.
<<Битовый левый сдвиг оператор. Значение левого операнда сдвигается влево на количество бит, указанное правым операндом.A << 2 будет равен 240, то есть 1111 0000
>>Битовый правый сдвиг оператор. Значение левого операнда сдвигается вправо на количество бит, указанное правым операндом.A >> 2 будет равен 15, то есть 0000 1111

Онлайн пример

Пожалуйста, посмотрите на следующий пример, чтобы понять все доступные битовые операторы в C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a = 60; /* 60 = 0011 1100 */　　
　　　　　　　　　　　　int b = 13; /* 13 = 0000 1101 */
　　　　　　　　　　　　int c = 0;　　　　　　　　　　　
　　　　　　　　　　　　　c = a & b; /* 12 = 0000 1100 */　
　　　　　　　　　　　　　Console.WriteLine("Строка 1 - значение c равно {0}", c);
　　　　　　　　　　　　　c = a | b; /* 61 = 0011 1101 */
　　　　　　　　　　　　　Console.WriteLine("Строка 2 - значение c равно {0}", c);
　　　　　　　　　　　　　c = a ^ b; /* 49 = 0011 0001 */
　　　　　　　　　　　　　Console.WriteLine("Строка 3 - значение c равно {0}", c);
　　　　　　　　　　　　　c = ~a; /* -61 = 1100 0011 */
　　　　　　　　　　　　　Console.WriteLine("Строка 4 - значение c равно {0}", c);
　　　　　　　　　　　　　c = a << 2; /* 240 = 1111 0000 */
　　　　　　　　　　　　　Console.WriteLine("Строка 5 - значение c равно {0}", c);
　　　　　　　　　　　　　c = a >> 2; /* 15 = 0000 1111 */
　　　　　　　　　　　　　Console.WriteLine("Строка 6 - значение c равно {0}", c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Когда上面的 код будет скомпилирован и выполнен, он произведет следующие результаты:

Строка 1 - значение c равно 12
Строка 2 - значение c равно 61
Строка 3 - значение c равно 49
Строка 4 - значение c равно -61
Строка 5 - значение c равно 240
Строка 6 - значение c равно 15

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

В таблице приведены операторы присваивания, поддерживаемые C#

ОператорыОписаниеПример
=Просто оператор присваивания, которыйassigns значение правого операнда левому операндуC = A + B asigns значение A + B C
+=Оператор сложения и присваивания, которыйassigns результат сложения правого операнда с левым операндомC += A эквивалентно C = C + A
-=Оператор вычитания и присваивания, которыйassigns результат вычитания правого операнда из левого операндаC -= A эквивалентно C = C - A
*=Оператор умножения и присваивания, которыйassigns результат умножения правого операнда на левый операндC *= A эквивалентно C = C * A
/=Оператор деления и присваивания, которыйassigns результат деления левого операнда правому операндуC /= A эквивалентно C = C / A
%=Оператор модуля и присваивания, модуль двух операндов присваивается левой operandуC %= A эквивалентно C = C % A
<<=Сдвиг влево и присваиваниеC <<= 2 эквивалентно C = C << 2
>>=Сдвиг вправо и присваиваниеC >>= 2 эквивалентно C = C >> 2
&=Битовое и и присваиваниеC &= 2 эквивалентно C = C & 2
^=Битовое исключающее или и присваиваниеC ^= 2 эквивалентно C = C ^ 2
|=Битовое или и присваиваниеC |= 2 эквивалентно C = C | 2

Онлайн пример

Пожалуйста, посмотрите на следующий пример, чтобы понять все доступные операторы присваивания в C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a = 21;
　　　　　　　　　　　　int c;
　　　　　　　　　　　　c = a;
　　　　　　　　　　　　Console.WriteLine("Строка 1 - =　c значение = {0}", c);
　　　　　　　　　　　　c += a;
　　　　　　　　　　　　Console.WriteLine("Строка 2 - += c значение = {0}", c);
　　　　　　　　　　　　c -= a;
　　　　　　　　　　　　Console.WriteLine("Строка 3 - -=　c значение = {0}", c);
　　　　　　　　　　　　c *= a;
　　　　　　　　　　　　Console.WriteLine("Строка 4 - *=　c значение = {0}", c);
　　　　　　　　　　　　c /= a;
　　　　　　　　　　　　Console.WriteLine("Строка 5 - /=　c значение = {0}", c);
　　　　　　　　　　　　c = 200;
　　　　　　　　　　　　c %= a;
　　　　　　　　　　　　Console.WriteLine("Строка 6 - %=　c значение = {0}", c);
　　　　　　　　　　　　c <<= 2;
　　　　　　　　　　　　Console.WriteLine("Строка 7 - <<=　c значение = {0}", c);
　　　　　　　　　　　　c >>= 2;
　　　　　　　　　　　　Console.WriteLine("Строка 8 - >>=　c значение = {0}", c);
　　　　　　　　　　　　c &= 2;
　　　　　　　　　　　　Console.WriteLine("Строка 9 - &=　c значение = {0}", c);
　　　　　　　　　　　　c ^= 2;
　　　　　　　　　　　　Console.WriteLine("Строка 10 - ^=　c значение = {0}", c);
　　　　　　　　　　　　c |= 2;
　　　　　　　　　　　　Console.WriteLine("Строка 11 - |=　c значение = {0}", c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Когда上面的 код будет скомпилирован и выполнен, он произведет следующие результаты:

Строка 1 - =　c значение = 21
Строка 2 - +=　c значение = 42
Line 3 - -=　 значение c = 21
Line 4 - *=　 значение c = 441
Line 5 - /=　 значение c = 21
Line 6 - %=　 значение c = 11
Line 7 - <<=　 значение c = 44
Line 8 - >>=　 значение c = 11
Line 9 - &=　 значение c = 2
Line 10 - ^=　 значение c = 0
Line 11 - |=　 значение c = 2

Другие операторы

В таблице приведены другие важные операторы, поддерживаемые C#, включая sizeof、typeof И ? :.

ОператорыОписаниеПример
sizeof();Возвращает размер данных типа.sizeof(int) вернет 4.
typeof();Возвращает тип класса.typeof(StreamReader);
&Возвращает адрес переменной.&a; будет получить фактический адрес переменной.
*Указатель переменной.*a; будет указывать на переменную.
? :Кондиционное выражениеЕсли условие истинно ? то X : иначе Y
isОпределение, является ли объект определенного типа.If( Ford is Car) // Проверка, является ли Ford объектом класса Car.
asПринудительное преобразование, даже если преобразование失败, не вызывает исключение.Object obj = new StringReader("Hello");
　 　StringReader r = obj as StringReader;

Онлайн пример

using System;
namespace OperatorsAppl
{
　　　　
　　　class Program
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　
　　　　　　　　　/* Пример оператора sizeof */
　　　　　　　　　Console.WriteLine("Размер int составляет {0}", sizeof(int));
　　　　　　　　　Console.WriteLine("Размер short составляет {0}", sizeof(short));
　　　　　　　　　Console.WriteLine("Размер double составляет {0}", sizeof(double));
　　　　　　　　　
　　　　　　　　　/* Пример三元 оператора */
　　　　　　　　　int a, b;
　　　　　　　　　a = 10;
　　　　　　　　　b = (a == 1) ? 20 : 30;
　　　　　　　　　Console.WriteLine("Значение b составляет {0}", b);
　　　　　　　　　b = (a == 10) ? 20 : 30;
　　　　　　　　　Console.WriteLine("Значение b составляет {0}", b);
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

Когда上面的 код будет скомпилирован и выполнен, он произведет следующие результаты:

Размер int составляет 4
Размер short составляет 2
Размер double составляет 8
Значение b составляет 30
Значение b равно 20

Приоритет операторов в C#

Приоритет операторов определяет комбинацию элементов в выражении и влияет на то, как выражение вычисляется. Некоторые операторы имеют более высокий приоритет, чем другие, например, операторы умножения и деления имеют более высокий приоритет, чем операторы сложения и вычитания.

Например, x = 7 + 3 * 2, в этом случае x будет равно 13, а не 20, потому что оператор * имеет более высокий приоритет, чем +, поэтому сначала вычисляется умножение 3*2, а затем к 7.

В таблице ниже приведены все операторы в порядке их приоритета от высокого к низкому. Операторы с более высоким приоритетом показаны вверху таблицы, а операторы с более низким приоритетом - внизу. В выражениях операторы с более высоким приоритетом вычисляются в первую очередь.

Категория　Операторы　Ассоциативность　
Префикс　( ) [] -> . ++ -- 　Слева направо　
Унарные　+ - ! ~ ++ -- (type)* & sizeof　Справа налево　
Умножение и деление　* / %　Слева направо　
Сложение и вычитание　+ -　Слева направо　
Сдвиг　<< >>　Слева направо　
Отношение　< <= > >=　Слева направо　
Равенство　== !=　Слева направо　
Битовое И AND　&　Слева направо　
Битовое ИЛИ XOR　^　Слева направо　
Битовое ИЛИ OR　|　Слева направо　
Логическое И AND　&&　Слева направо　
Логическое ИЛИ OR　||　Слева направо　
Условие　?:　Справа налево　
Ассигнование　= += -= *= /= %= =>>= <<= &= ^= |=　Справа налево　
Запятая　,　Слева направо　

Онлайн пример

using System;
namespace OperatorsAppl
{
　　　　
　　　class Program
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　int a = 20;
　　　　　　　　　int b = 10;
　　　　　　　　　int c = 15;
　　　　　　　　　int d = 5;
　　　　　　　　　int e;
　　　　　　　　　e = (a + b) * c / d; // (30 * 15) / 5
　　　　　　　　　Console.WriteLine("(a + b) * c / d значение {0}", e);
　　　　　　　　　e = ((a + b) * c) / d; // (30 * 15) / 5
　　　　　　　　　Console.WriteLine("((a + b) * c) / d значение {0}", e);
　　　　　　　　　e = (a + b) * (c / d); // 30 * (15/5)
　　　　　　　　　Console.WriteLine("(a + b) * (c / d) значение {0}", e);
　　　　　　　　　e = a + (b * c) / d; // 20 + (150/5)
　　　　　　　　　e = a + (b * c) / d; // 20 + (150/5)
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

Когда上面的 код будет скомпилирован и выполнен, он произведет следующие результаты:

Worth of (a + b) * c / d is 90
Worth of ((a + b) * c) / d is 90
Worth of (a + b) * (c / d) is 90
Worth of a = + (b * c) / d is 50
FileInfo в C#Интерфейсы (Interface) в C#