Latest web development tutorials

C # Operatoren

Operator ist ein Symbol, um den Compiler zu sagen, bestimmte mathematische oder logische Operationen auszuführen. C # hat eine Fülle von eingebauten Operatoren, wie folgt:

  • Arithmetische Operatoren
  • Relationale Operatoren
  • Logische Operatoren
  • Bitweise Operatoren
  • Zuweisungsoperatoren
  • Verschiedene Betreiber

Dieses Tutorial wird jede der arithmetischen Operatoren, relationale Operatoren, logische Operatoren Bit-Operatoren Zuweisungsoperator und andere Betreiber erklären.

Arithmetische Operatoren

Die folgende Tabelle zeigt die C # Unterstützung alle arithmetischen Operatoren.Ein Wert von 10 wird angenommen , Variable, die Variable B20 ist , dann:

运算符描述实例
+把两个操作数相加 A + B 将得到 30
-从第一个操作数中减去第二个操作数 A - B 将得到 -10
*把两个操作数相乘 A * B 将得到 200
/分子除以分母 B / A 将得到 2
%取模运算符，整除后的余数 B % A 将得到 0
++自增运算符，整数值增加 1 A++ 将得到 11
--自减运算符，整数值减少 1 A-- 将得到 9

Beispiele

Betrachten Sie die folgenden Beispiele C # alle verfügbaren arithmetischen Operatoren zu lernen: 

using System;

Namespace OperatorsAppl
{
    Klasse-Programm
    {
        static void Main (string [] args)
        {
            int a = 21;
            int b = 10;
            int c;

            c = a + b;
            Console.WriteLine ( "1 Line - c {0}", c);
            c = a - b;
            Console.WriteLine ( "2 Line - c {0}", c);
            c = a * b;
            Console.WriteLine ( "3 Line - c {0}", c);
            c = a / b;
            Console.WriteLine ( "4 Line - C ist {0}", c);
            c = a% b;
            Console.WriteLine ( "Linie 5 - c {0}", c);

            // ++ Eine erste Inkrementbetrieb durchgeführt durch Zuweisung c = ++ a;
            Console.WriteLine ( "6 Line - c {0}", c);

            // In diesem Fall wird ein Wert von 22
            // --a Erste Selbst Subtraktion durch Zuweisung c = --a;
            Console.WriteLine ( "7-Linie - c {0}", c);
            Console.ReadLine ();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse: 

1 Line - der Wert von c ist 31
2 Line - der Wert von c ist 11
3 Line - ist der Wert von c 210
4 Line - der Wert von c 2
Linie 5 - der Wert von c 1
6 Line - der Wert von c ist 22
7 Line - der Wert von c ist 21
  • c = a ++: eine erste Zuordnung zu c, und dann auf einem selbst Inkrementoperator.
  • c = ++ a: zunächst ein Selbst Inkrementoperator, und dann zu einem c zugeordnet.
  • c = A--: eine erste Zuordnung zu C und dann auf einer selbst Subtraktion.
  • c = -A: zuerst eine Selbst Subtraktion, dann zu einer c zugeordnet. 
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();
        }
    }
}

Ausführung einer Instanz »

Das obige Programm, das Ausgabe ist: 

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

Relationale Operatoren

Die folgende Tabelle zeigt die C # Unterstützung alle relationalen Operatoren.Ein Wert von 10 wird angenommen , Variable, die Variable B20 ist , dann:

运算符描述实例
==检查两个操作数的值是否相等，如果相等则条件为真。 (A == B) 不为真。
!=检查两个操作数的值是否相等，如果不相等则条件为真。 (A != B) 为真。
>检查左操作数的值是否大于右操作数的值，如果是则条件为真。 (A > B) 不为真。
<检查左操作数的值是否小于右操作数的值，如果是则条件为真。 (A < B) 为真。
>=检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 (A >= B) 不为真。
<=检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 (A <= B) 为真。

Beispiele

Betrachten Sie die folgenden Beispiele C # alle verfügbaren relationalen Operatoren zu lernen: 

using System;

Klasse-Programm
{
  static void Main (string [] args)
  {
      int a = 21;
      int b = 10;
      
      if (a == b)
      {
          Console.WriteLine ( "Line 1 - a gleich b");
      }
      sonst
      {
          Console.WriteLine ( "Line 1 - a nicht gleich b");
      }
      wenn (a <b)
      {
          Console.WriteLine ( "Linie 2 - a kleiner als b");
      }
      sonst
      {
          Console.WriteLine ( "Linie 2 - ein nicht weniger als b");
      }
      if (a> b)
      {
          Console.WriteLine ( "Line 3 - a größer als b");
      }
      sonst
      {
          Console.WriteLine ( "Line 3 - ein nicht größer als b");
      }
      / * Ändern Sie den Wert von a und b * /
      a = 5;
      b = 20;
      if (a <= b)
      {
         Console.WriteLine ( "Line 4 - a kleiner oder gleich b");
      }
      if (b> = a)
      {
         Console.WriteLine ( "Linie 5 - b ist größer als oder gleich a");
      }
  }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse: 

Linie 1 - a nicht gleich b ist
Linie 2 - ein nicht weniger als b
Linie 3 - a größer als b
Linie 4 - a kleiner oder gleich b ist
Linie 5 - b ist größer als oder gleich a

Logische Operatoren

Die folgende Tabelle zeigt die C # Unterstützung alle logischen Operatoren. Angenommen , die VariableA Boolesche Wert true, wird die Variable Bist ein boolescher Wert falsch ist , dann:

运算符描述实例
&&称为逻辑与运算符。如果两个操作数都非零，则条件为真。 (A && B) 为假。
||称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 (A || B) 为真。
!称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 !(A && B) 为真。

Beispiele

Betrachten Sie die folgenden Beispiele C # alle verfügbaren logischen Operatoren zu lernen: 

using System;

Namespace OperatorsAppl
{
    Klasse-Programm
    {
        static void Main (string [] args)
        {
            bool a = true;
            bool b = true;
           
            wenn (a && b)
            {
               Console.WriteLine ( "Linie 1 - Bedingung ist wahr");
            }
            wenn (a || b)
            {
                Console.WriteLine ( "Linie 2 - Bedingung ist wahr");
            }
            / * Ändern Sie den Wert von a und b * /
            a = false;
            b = true;
            wenn (a && b)
            {
                Console.WriteLine ( "Line 3 - Bedingung ist wahr");
            }
            sonst
            {
                Console.WriteLine ( "Line 3 - der Zustand ist nicht wahr");
            }
            if (! (a && b))
            {
                Console.WriteLine ( "Linie 4 - Bedingung ist wahr");
            }
            Console.ReadLine ();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse: 

Linie 1 - die Bedingung wahr Linie 2 - Die Bedingung ist wahr Linie 3 - die Bedingung nicht wahr Linie 4 - Bedingung erfüllt ist

Bitweise Operatoren

Bitoperatoren auf dem Bohrmeißel wirkenden, und nach und nach Betrieb. &, | Und ^ Wahrheitstabelle ist wie folgt:

pqp & qp | qp ^ q
00000
01011
11110
10011

Angenommen, wenn A = 60 und B = 13, und nun, in binärer Form, sind wie folgt:

A = 0011 1100

B = 0000 1101

-----------------

A & B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~ A = 1100 0011

In der folgenden Tabelle sind die C # Unterstützung Bitoperatoren. Angenommen , die VariableA ist 60, wird der Wert der Variable B13, dann gilt :

运算符描述实例
&如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。 (A & B) 将得到 12，即为 0000 1100
|如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。 (A | B) 将得到 61，即为 0011 1101
^如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。 (A ^ B) 将得到 49，即为 0011 0001
~二进制补码运算符是一元运算符，具有"翻转"位效果。(~A ) 将得到 -61，即为 1100 0011，2 的补码形式，带符号的二进制数。
<<二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 A << 2 将得到 240，即为 1111 0000
>>二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 A >> 2 将得到 15，即为 0000 1111

Beispiele

Betrachten Sie die folgenden Beispiele C #, alle verfügbaren Bits Betreiber zu lernen: 

using System;
Namespace OperatorsAppl
{
    Klasse-Programm
    {
        static void Main (string [] args)
        {
            60 int a = / * 60 = 0011 1100 * /  
            13 int b = / * 13 = 0000 1101 * /
            int c = 0;           

             c = a & b / * 12 = 0000 1100 * / 
             Console.WriteLine ( "1 Line - c {0}", c);

             c = a | b / * 61 = 0011 1101 * /
             Console.WriteLine ( "2 Line - c {0}", c);

             c = a ^ b / * 49 = 0011 0001 * /
             Console.WriteLine ( "3 Line - c {0}", c);

             a c = ~ / * - 61 = 1100 0011 * /
             Console.WriteLine ( "4 Line - C ist {0}", c);

             c = a << 2 / * 240 = 1111 0000 * /
             Console.WriteLine ( "Linie 5 - c {0}", c);

             c = a >> 2 / * 15 = 0000 1111 * /
             Console.WriteLine ( "6 Line - c {0}", c);
            Console.ReadLine ();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse: 

1 Line - der Wert von c ist 12
2 Line - der Wert von c ist 61
3 Line - der Wert von c ist 49
4 Linie - Wert c ist -61
Linie 5 - der Wert von c ist 240
6 Line - der Wert von c ist 15

Zuweisungsoperatoren

In der folgenden Tabelle sind die C # den Zuweisungsoperator unterstützen:

运算符描述实例
=简单的赋值运算符，把右边操作数的值赋给左边操作数 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

Beispiele

Betrachten Sie die folgenden Beispiele C # in allen verfügbaren Zuweisungsoperatoren zu erfahren: 

using System;

Namespace OperatorsAppl
{
    Klasse-Programm
    {
        static void Main (string [] args)
        {
            int a = 21;
            int c;

            c = a;
            Console.WriteLine ( "Linie 1 - = c-Wert = {0}", c);

            c + = a;
            Console.WriteLine ( "Linie 2 - + = c-Wert = {0}", c);

            c - = a;
            Console.WriteLine ( "Line 3 - - = c-Wert = {0}", c);

            c * = a;
            Console.WriteLine ( "Linie 4 - * = c-Wert = {0}", c);

            c / = a;
            Console.WriteLine ( "Linie 5 - / = c-Wert = {0}", c);

            c = 200;
            c% = a;
            Console.WriteLine ( "Line 6 -% = c-Wert = {0}", c);

            c << = 2;
            Console.WriteLine ( "Linie 7 - << = C-Wert = {0}", c);

            c >> = 2;
            Console.WriteLine ( "Linie 8 - >> = C-Wert = {0}", c);

            c & = 2;
            Console.WriteLine ( "Linie 9 - & = c-Wert = {0}", c);

            c ^ = 2;
            Console.WriteLine ( "Linie 10 - ^ = c-Wert = {0}", c);

            c | = 2;
            Console.WriteLine ( "Line 11 - | = c-Wert = {0}", c);
            Console.ReadLine ();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse: 

Linie 1 - = c = Wert 21
Linie 2 - + = Wert von c = 42
3 Line - - = Wert von c = 21
4 Linie - * = Wert von c = 441
Linie 5 - / = c = Wert 21
6 Line -% = der Wert von c = 11
7 Zeile - << = Wert von c = 44
8 Line - der Wert >> = c = 11
9 Linie - & = Wert von c = 2
Linie 10 - ^ = c = 0 Wert
Zeile 11 - | = c 2 = Wert

Verschiedene Betreiber

In der folgenden Tabelle sind die C # einige andere wichtige Betreiber unterstützen, einschließlichsizeof, typeofund?:.

Die Betreiber Beschreibung Beispiele sizeof () Rückgabedatentyp Größe. sizeof (int), wird 4 zurück. typeof () Gibt den Klassentyp. typeof (Stream); & Rücksendeadresse variabel. & A; Sie erhalten die tatsächliche Adresse der Variablen erhalten. * Pointer-Variable. * A; wird auf eine Variable verweisen. ?: Bedingte Ausdruck ? Wenn die Bedingung wahr ist, oder X: Y anders ist Bestimmt, ob ein Objekt eines bestimmten Typs. Wenn (Ford Car) // überprüfen, ob ein Objekt Ford Car-Klasse. als Cast, auch wenn die Konvertierung fehlschlägt es nicht eine Ausnahme ausgelöst wird. Object obj = new String ( "Hallo");
String r = obj als String;

Beispiele 

using System;

Namespace OperatorsAppl
{
    
   Klasse-Programm
   {
      static void Main (string [] args)
      {
         
         / * Operator sizeof Instanz * /
         Console.WriteLine ( "int size ist {0}", sizeof (int));
         Console.WriteLine ( "kurze Größe ist {0}", sizeof (kurz));
         Console.WriteLine ( "doppelt so groß wie der {0}", sizeof (double));
         
         / * Ternary Operator bricht Instanz * /
         int a, b;
         a = 10;
         b = (a == 1) 20: 30 ;?
         Console.WriteLine ( "b-Werte sind {0}", b);

         b = (a == 10) 20: 30 ;?
         Console.WriteLine ( "b-Werte sind {0}", b);
         Console.ReadLine ();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse: 

Int Größe 4
kurze Größe ist 2
doppelte Größe 8
b-Werte sind 30
b-Werte sind 20

In C # Operator Vorrang

Operator Vorrang einen kombinierten Begriff eines Ausdrucks bestimmen. Dies wirkt wie ein Ausdruck Berechnung. Einige Betreiber haben eine höhere Priorität als andere Operatoren wie Addition und Subtraktion, Multiplikation und Division Betreiber als dem Betreiber eine höhere Priorität.

Zum Beispiel x = 7 + 3 * 2, wobei x bis 13 statt 20 zugeordnet ist, weil der Operator * höhere Priorität als + hat, so berechnen zuerst die Multiplikation 3 * 2, dann 7 hinzufügen.

In der folgenden Tabelle wird für jeden Betreiber in der Reihenfolge der Rangfolge der Operatoren aufgelistet werden, mit den oben höhere Priorität Operatoren in der Tabelle angezeigt werden, mit den folgenden niedrigeren Priorität Operatoren in der Tabelle angezeigt werden. In dem Ausdruck höherer Priorität Operatoren Priorität berechnet wird.

类别  运算符 结合性 
后缀 () [] -> . ++ - -   从左到右 
一元  + - ! ~ ++ - - (type)* & sizeof  从右到左 
乘除  * / % 从左到右 
加减 + -  从左到右 
移位  << >>  从左到右 
关系 < <= > >=  从左到右 
相等  == !=  从左到右 
位与 AND &  从左到右 
位异或 XOR  ^  从左到右 
位或 OR  |  从左到右 
逻辑与 AND &&  从左到右 
逻辑或 OR  ||  从左到右 
条件 ?:  从右到左 
赋值  = += -= *= /= %=>>= <<= &= ^= |= 从右到左 
逗号  ,  从左到右 

Beispiele 

using System;

Namespace OperatorsAppl
{
    
   Klasse-Programm
   {
      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 ( "Wert (a + b) * c / d {0}", e);

         e = ((a + b) * c) / d; // (30 * 15) / 5
         Console.WriteLine ( "Wert ((a + b) * c) / d {0}", e);

         e = (a + b) * (c / d); // (30) * (15/5)
         Console.WriteLine ( "(a + b) * (c / d) Werte sind {0}", e);

         e = a + (b * c) / d; // 20 + (150/5)
         Console.WriteLine ( "Wert von a + (b * c) / d {0}", e);
         Console.ReadLine ();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse: 

Wert (a + b) * c / d 90
Wert ((a + b) * c) / d 90
(A + B) * (c / d) Wert ist 90
Der Wert von a + (b * c) / d 50