Energy
education

сайт для тех, кто хочет изучать энергетику

7. Операторы

Оператор является символом, который говорит компилятору выполнять определенные математические и логические действия. 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
    

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

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

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 тогда:

ОператорОписаниеПример
&Битовый оператор И копирует бит в результат если он присутствует в обоих операндах. (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