Оператор является символом, который говорит компилятору выполнять определенные математические и логические действия. C# имеет множество встроенных операторов и предоставляет следующие типы операторов:
Следующая таблица иллюстрирует все арифметические операторы поддерживаемые C#. Предположим, переменная A содержит значение 10 и переменная B содержит значение 20, тогда:
Оператор | Описание | Пример |
---|---|---|
+ | Сложение двух операндов | A + B даст 30 |
- | Вычитание второго операнда из первого | A - B даст -10 |
* | Перемножение двух операндов | A * B даст 200 |
/ | Деление числителя на знаменатель | B / A даст 2 |
% | Остаток после целочисленного деления | B % A даст 0 |
++ | Увеличение целого значения на единицу | A++ даст 11 |
-- | Уменьшение целого значения на единицу | A-- даст 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);
c = a++;
Console.WriteLine("Строка 6 - Значение c = {0}", c);
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 = 21
Строка 7 - Значение c = 22
Следующая таблица иллюстрирует все операторы отношения поддерживаемые C#. Предположим, переменная A содержит значение 10 и переменная B содержит значение 20, тогда:
Оператор | Опиание | Пример |
---|---|---|
== | Проверяет, являются ли значение двух операндов равными или нет, если да, то состояние становится true. | (A == B) это не так, состояние становиться false. |
!= | Проверяет, являются ли значение двух операндов равными или нет, если нет, то состояние становится true. | (A != B) это true. |
> | Проверяет, является ли значение левого операнда больше, чем значение правого операнда, если да, то Значение становится true. | (A > B) это не true. |
< | Проверяет, является ли значение левого операнда меньше, чем значение правого операнда, если да, то состояние становится true. | (A < B) это true. |
>= | Проверяет, если значение левого операнда больше или равно значению правого операнда, если да, то Значение становится true | (A >= B) это не true. |
<= | Проверяет, если значение левого операнда меньше или равно значению правого операнда, если да, то Значение становится true. | (A <= B) это true. |
Попробуйте следующий пример, чтобы понять все операторы отношения, доступные в 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("Line 5 - b больше или равно a");
}
}
}
Если приведенный выше код скомпилиовать и выполнить, это приведет к следующему результату:
Строка 1 - a не равно b
Строка 2 - a не меньше чем b
Строка 3 - a больше чем b
Строка 4 - a меньше или равно b
Строка 5 - b больше или равно a
Следующая таблица показывает все логические операторы поддерживаемые C#. Предположим, переменная A содержит Boolean значение true и переменная B содержит Boolean значение false тогда:
Оператор | Описание | Пример |
---|---|---|
&& | Называется оператор логического И. Если оба операнда ненулевые то значение становится true. | (A && B) это false. |
|| | Называется оператор логического ИЛИ. Если любой из двух операндов не равен нулю, то значение становится true. | (A || B) это true. |
! | Называется оператор логического НЕ. Используется для преобразования операнда на противоположный. Если состояние true тогда оператор НЕ вернет false. | !(A && B) это true. |
Попробуйте следующий пример, чтобы понять все логические операторы, доступные в C#:
using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
bool a = true;
bool b = true;
if (a && b)
{
Console.WriteLine("Строка 1 - Значение true");
}
if (a || b)
{
Console.WriteLine("Строка 2 - Значение true");
}
/* давайте заменим значения a и b */
a = false;
b = true;
if (a && b)
{
Console.WriteLine("Строка 3 - Значение true");
}
else
{
Console.WriteLine("Строка 3 - Значение не true");
}
if (!(a && b))
{
Console.WriteLine("Строка 4 - Значение true");
}
Console.ReadLine();
}
}
}
Если приведенный выше код скомпилиовать и выполнить, это приведет к следующему результату:
Строка 1 - Значение true
Строка 2 - Значение true
Строка 3 - Значение не true
Строка 4 - Значение true
Битовые операторы работ по битам и выполняет операции бит за битом. Таблица истинности для &, |, и ^ следующая:
p | q | p & q | p | q | p ^ q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
Предположим если 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 тогда:
Оператор | Описание | Пример |
---|---|---|
& | Битовый оператор И копирует бит в результат если он присутствует в обоих операндах. | (A & B) будет равно 12 что также 0000 1100 |
| | Битовый оператор ИЛИ копирует бит если он существует в любом из операндов. | (A | B) будет равно 61 что также 0011 1101 |
^ | Битовый оператор XOR копирует бит если он существует в одном операнде, но не в обоих. | (A ^ B) будет равно 49 что также 0011 0001 |
~ | Битовый унитарный оператор имеет эффект похожий на "переворот" бит. | (~A ) будет равно 195 что также 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#:
Оператор | Описание | Пример |
---|---|---|
= | Простой оператор присваивания. Присваивает значения правого операнда левому операнду | C = A + B присвоит значение A + B в C |
+= | Сложение и оператор присваивания. Присваивает значение сложения правого операнда с левым операндом левому операнду | C += A эквивалентно C = C + A |
-= | Вычитание и оператор присваивания. Присваивает значение вычитания из левого операнда правого операнда левому операнду | C -= A эквивалентно C = C - A |
*= | Умножение и оператор присваивания. Присваивает значение перемножения правого операнда с левым операндом левому операнду | C *= A эквивалентно C = C * A |
/= | Деление и оператор присваивания. Присваивает значение деления левого операнда на правый операнд левому операнду | C /= A эквивалентно C = C / A |
%= | Остаток после деления и оператор присваивания. Присваивает значение остатка от деления левого операнда на правый операнд левому операнду | 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
Строка 3 - -= Значение c = 21
Строка 4 - *= Значение c = 441
Строка 5 - /= Значение c = 21
Строка 6 - %= Значение c = 11
Строка 7 - <<= Значение c = 44
Строка 8 - >>= Значение c = 11
Строка 9 - &= Значение c = 2
Строка 10 - ^= Значение c = 0
Строка 11 - |= Значение c = 2
Есть несколько других важных операторов, включая sizeof, typeof и ? : поддерживаемых C#.
Оператор | Описание | Пример |
---|---|---|
sizeof() | Возвращает размер типа данных. | sizeof(int), вернет 4. |
typeof() | Возвращает тип класса. | typeof(StreamReader); |
& | Возвращает адрес переменной. | &a; даст фактический адрес переменной. |
* | Указатель на переменную. | *a; укажет на переменную. |
? : | Условное выражение | Если условие истина ? тогда значение X : иначе значение Y |
is | Определяет, является ли объект определенного типа. | If( Ford is Car) // Проверяет, является ли Ford объектом класса Car. |
as | Оператор as подобен оператору приведения. Однако если преобразование невозможно, то as возвращает null вместо вызова исключения. |
Object obj = new StringReader("Привет"); 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