C# Operatoren

Ein Operator ist ein Symbol, das den Compiler anweist, bestimmte mathematische oder logische Operationen auszuführen. C# verfügt über umfangreiche integrierte Operatoren, die wie folgt kategorisiert werden:

  • Arithmetische Operatoren
  • Relationale Operatoren
  • Logische Operatoren
  • Bitweise Operatoren
  • Zuweisungsoperatoren
  • Weitere Operatoren

In diesem Tutorial werden arithmetische Operatoren, relationale Operatoren, logische Operatoren, bitweise Operatoren, Zuweisungsoperatoren und andere Operatoren nacheinander erklärt.

Arithmetische Operatoren

Die folgende Tabelle zeigt alle von C# unterstützten arithmetischen Operatoren. Angenommen, die VariableAhat den Wert 10, die VariableBhat den Wert 20, dann:

OperatorenBeschreibungBeispiel
+Addiert zwei Operanden.A + B ergibt 30
-Subtrahiert den zweiten Operanden vom ersten Operanden.A - B ergibt -10
*Multipliziert zwei Operanden.A * B ergibt 200
/Zähler geteilt durch NennerB / A ergibt 2
%Modulo-Operator, Rest nach ganzzahliger Division.B % A ergibt 0
++Inkrementoperator, erhöht einen ganzzahligen Wert um 1.A++ ergibt 11
--Dekrementoperator, verringert einen ganzzahligen Wert um 1.A-- ergibt 9

Beispiel

Siehe das folgende Beispiel, um alle in C# verfügbaren arithmetischen Operatoren zu verstehen:

Beispiel

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 21;
            int b = 10;
            int c;

            c = a + b;
            Console.WriteLine("Zeile 1 - der Wert von c ist {0}", c);
            c = a - b;
            Console.WriteLine("Zeile 2 - der Wert von c ist {0}", c);
            c = a * b;
            Console.WriteLine("Zeile 3 - der Wert von c ist {0}", c);
            c = a / b;
            Console.WriteLine("Zeile 4 - der Wert von c ist {0}", c);
            c = a % b;
            Console.WriteLine("Zeile 5 - der Wert von c ist {0}", c);

            // ++a wird vor der Zuweisung inkrementiert
            c = ++a;
            Console.WriteLine("Zeile 6 - der Wert von c ist {0}", c);

            // An diesem Punkt ist der Wert von a 22
            // --a wird vor der Zuweisung dekrementiert
            c = --a;
            Console.WriteLine(Zeile 7 - Der Wert von c ist {0}, c);
            Console.ReadLine();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 22
Line 7 - c 的值是 21
  • c = a++: Weise zuerst a c zu, dann inkrementiere a.
  • c = ++a: Inkrementiere zuerst a, dann weise a c zu.
  • c = a--: Weise zuerst a c zu, dann dekrementiere a.
  • c = --a: Dekrementiere zuerst a, dann weise a c zu.

Beispiel

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 1;
            int b;

            // a++ weist zu, bevor inkrementiert wird
            b = a++;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();

            // ++a wird vor der Zuweisung inkrementiert
            a = 1; // a neu initialisieren
            b = ++a;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();

            // a-- weist zu, bevor dekrementiert wird
            a = 1;  // a neu initialisieren
            b= a--;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();

            // --a wird vor der Zuweisung dekrementiert
            a = 1;  // a neu initialisieren
            b= --a;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();
        }
    }
}

Beim Ausführen des obigen Programms lautet das Ausgabeergebnis:

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

Relationale Operatoren

Die folgende Tabelle zeigt alle von C# unterstützten relationalen Operatoren. Angenommen, VariableAhat den Wert 10, VariableBhat den Wert 20, dann:

OperatorenBeschreibungBeispiel
==Prüft, ob die Werte zweier Operanden gleich sind; wenn sie gleich sind, ist die Bedingung wahr.(A == B) ist nicht wahr.
!=Prüft, ob die Werte zweier Operanden gleich sind; wenn sie nicht gleich sind, ist die Bedingung wahr.(A != B) ist wahr.
>Prüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist; wenn ja, ist die Bedingung wahr.(A > B) ist nicht wahr.
<Prüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist; wenn ja, ist die Bedingung wahr.(A < B) ist wahr.
>=Prüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist; wenn ja, ist die Bedingung wahr.(A >= B) ist nicht wahr.
<=Prüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist; wenn ja, ist die Bedingung wahr.(A <= B) ist wahr.

Beispiel

Siehe das folgende Beispiel, um alle in C# verfügbaren relationalen Operatoren zu verstehen:

Beispiel

using System;

class Program
{
  static void Main(string[] args)
  {
      int a = 21;
      int b = 10;
     
      if (a == b)
      {
          Console.WriteLine("Zeile 1 - a ist gleich b");
      }
      else
      {
          Console.WriteLine("Zeile 1 - a ist nicht gleich b");
      }
      if (a < b)
      {
          Console.WriteLine("Zeile 2 - a ist kleiner als b");
      }
      else
      {
          Console.WriteLine("Zeile 2 - a ist nicht kleiner als b");
      }
      if (a > b)
      {
          Console.WriteLine("Zeile 3 - a ist größer als b");
      }
      else
      {
          Console.WriteLine("Zeile 3 - a ist nicht größer als b");
      }
      /* Ändern Sie die Werte von a und b */
      a = 5;
      b = 20;
      if (a <= b)
      {
         Console.WriteLine(Zeile 4 - a ist kleiner oder gleich b);
      }
      if (b >= a)
      {
         Console.WriteLine(Zeile 5 - b ist größer oder gleich a);
      }
  }
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a

Logische Operatoren

Die folgende Tabelle zeigt alle von C# unterstützten logischen Operatoren. Angenommen, VariableAist ein boolescher Wert true, VariableBist ein boolescher Wert false, dann:

OperatorenBeschreibungBeispiel
&&Wird als logischer AND-Operator bezeichnet. Wenn beide Operanden ungleich null sind, ist die Bedingung wahr.(A && B) ist falsch.
||Wird als logischer OR-Operator bezeichnet. Wenn einer der beiden Operanden ungleich null ist, ist die Bedingung wahr.(A || B) ist wahr.
!Wird als logischer NICHT-Operator bezeichnet. Er wird verwendet, um den logischen Zustand eines Operanden umzukehren. Wenn die Bedingung wahr ist, macht der logische NICHT-Operator sie falsch.!(A && B) ist wahr.

Beispiel

Sehen Sie sich das folgende Beispiel an, um alle in C# verfügbaren logischen Operatoren zu verstehen:

Beispiel

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            bool a = true;
            bool b = true;
           
            if (a && b)
            {
               Console.WriteLine(Zeile 1 - Bedingung ist wahr);
            }
            if (a || b)
            {
                Console.WriteLine(Zeile 2 - Bedingung ist wahr);
            }
            /* Ändern Sie die Werte von a und b */
            a = false;
            b = wahr;
            if (a && b)
            {
                Console.WriteLine(Zeile 3 - Bedingung ist wahr);
            }
            else
            {
                Console.WriteLine("Zeile 3 - Bedingung ist nicht wahr");
            }
            if (!(a && b))
            {
                Console.WriteLine(Zeile 4 - Bedingung ist wahr);
            }
            Console.ReadLine();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Line 1 - 条件为真
Line 2 - 条件为真
Line 3 - 条件不为真
Line 4 - 条件为真

Bitweise Operatoren

Bitweise Operatoren wirken auf Bits und führen Operationen Bit für Bit aus. Die Wahrheitstabellen für &, | und ^ sind wie folgt:

pqp & qp | qp ^ q
00000
01011
11110
10011

Angenommen A = 60 und B = 13. Im Binärformat ausgedrückt sehen sie wie folgt aus:

A = 0011 1100

B = 0000 1101

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

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

Die folgende Tabelle listet die von C# unterstützten bitweisen Operatoren auf. Angenommen, VariableAhat den Wert 60, VariableBhat den Wert 13, dann:

OperatorenBeschreibungBeispiel
&Wenn er in beiden Operanden vorhanden ist, kopiert der binäre AND-Operator ein Bit in das Ergebnis.(A & B) ergibt 12, was 0000 1100 entspricht.
|Wenn er in einem der Operanden vorhanden ist, kopiert der binäre OR-Operator ein Bit in das Ergebnis.(A | B) ergibt 61, was 0011 1101 entspricht.
^Wenn er in einem Operanden, aber nicht in beiden vorhanden ist, kopiert der binäre XOR-Operator ein Bit in das Ergebnis.(A ^ B) ergibt 49, was 0011 0001 ist.
~Der bitweise Komplementoperator ist ein unärer Operator, der die Wirkung hat, Bits zu "kippen", das heißt, 0 wird zu 1 und 1 wird zu 0, einschließlich des Vorzeichenbits.(~A ) ergibt -61, was 1100 0011 ist, die Zweierkomplementform einer vorzeichenbehafteten Binärzahl.
<<Binärer Linksverschiebungsoperator. Der Wert des linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach links verschoben.A << 2 ergibt 240, was 1111 0000 ist.
>>Binärer Rechtsverschiebeoperator. Der Wert des linken Operanden wird um die Anzahl der durch den rechten Operanden angegebenen Bits nach rechts verschoben.A >> 2 ergibt 15, was 0000 1111 ist.

Beispiel

Siehe das folgende Beispiel, um alle in C# verfügbaren bitweisen Operatoren zu verstehen:

Beispiel

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("Zeile 1 - der Wert von c ist {0}", c );

             c = a | b;           /* 61 = 0011 1101 */
             Console.WriteLine("Zeile 2 - der Wert von c ist {0}", c);

             c = a ^ b;           /* 49 = 0011 0001 */
             Console.WriteLine("Zeile 3 - der Wert von c ist {0}", c);

             c = ~a;               /*-61 = 1100 0011 */
             Console.WriteLine("Zeile 4 - der Wert von c ist {0}", c);

             c = a << 2;     /* 240 = 1111 0000 */
             Console.WriteLine("Zeile 5 - der Wert von c ist {0}", c);

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

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15

Zuweisungsoperatoren

Die folgende Tabelle listet die von C# unterstützten Zuweisungsoperatoren auf:

OperatorenBeschreibungBeispiel
=Einfacher Zuweisungsoperator, weist dem linken Operanden den Wert des rechten Operanden zu.C = A + B weist C den Wert von A + B zu
+=Additions- und Zuweisungsoperator; weist dem linken Operanden das Ergebnis der Addition des rechten Operanden zum linken Operanden zu.C += A ist äquivalent zu C = C + A.
-=Subtraktions- und Zuweisungsoperator; weist dem linken Operanden das Ergebnis der Subtraktion des rechten Operanden vom linken Operanden zu.C -= A ist äquivalent zu C = C - A.
*=Multiplikations- und Zuweisungsoperator; weist dem linken Operanden das Ergebnis der Multiplikation des rechten Operanden mit dem linken Operanden zu.C *= A ist äquivalent zu C = C * A.
/=Divisions- und Zuweisungsoperator; weist dem linken Operanden das Ergebnis der Division des linken Operanden durch den rechten Operanden zu.C /= A ist äquivalent zu C = C / A.
%=Modulus- und Zuweisungsoperator, nimmt den Modulus zweier Operanden und weist ihn dem linken Operanden zu.C %= A ist äquivalent zu C = C % A.
<<=Linksverschiebungs- und Zuweisungsoperator.C <<= 2 ist äquivalent zu C = C << 2
>>=Rechtsverschiebungs- und Zuweisungsoperator.C >>= 2 ist äquivalent zu C = C >> 2
&=Bitweiser AND- und Zuweisungsoperator.C &= 2 ist äquivalent zu C = C & 2
^=Bitweiser XOR- und Zuweisungsoperator.C ^= 2 ist äquivalent zu C = C ^ 2
|=Bitweiser OR- und Zuweisungsoperator.C |= 2 ist äquivalent zu C = C | 2

Beispiel

Siehe das folgende Beispiel, um alle in C# verfügbaren Zuweisungsoperatoren zu verstehen:

Beispiel

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 21;
            int c;

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

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

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

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

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

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

            c <<= 2;
            Console.WriteLine(Zeile 7 - <<= Wert von c = {0}, c);

            c >>= 2;
            Console.WriteLine(Zeile 8 - >>= Wert von c = {0}, c);

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

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

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

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Line 1 - =     c 的值 = 21
Line 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

Weitere Operatoren

Die folgende Tabelle listet einige weitere wichtige Operatoren auf, die von C# unterstützt werden, daruntersizeof、typeofund? :。

OperatorenBeschreibungBeispiel
sizeof()Gibt die Größe eines Datentyps zurück.sizeof(int) gibt 4 zurück.
typeof()Gibt den Typ einer Klasse zurück.typeof(StreamReader);
&Gibt die Adresse einer Variablen zurück.&a; ermittelt die tatsächliche Adresse der Variablen.
*Zeiger auf eine Variable.*a; zeigt auf eine Variable.
? :Bedingter AusdruckWenn die Bedingung wahr ist ? dann X : andernfalls Y
istBestimmt, ob ein Objekt von einem bestimmten Typ ist.If( Ford is Car) // Prüft, ob Ford ein Objekt der Klasse Car ist.
asCast-Konvertierung; selbst wenn die Konvertierung fehlschlägt, wird keine Ausnahme ausgelöst.Object obj = new StringReader("Hello");
StringReader r = obj as StringReader;

Beispiel

Beispiel

using System;

namespace OperatorsAppl
{
   
   class Program
   {
      static void Main(string[] args)
      {
         
         /* Beispiel für den sizeof-Operator */
         Console.WriteLine("Die Größe von int ist {0}", sizeof(int));
         Console.WriteLine("Die Größe von short ist {0}", sizeof(short));
         Console.WriteLine("Die Größe von double ist {0}", sizeof(double));
         
         /* Beispiel für den ternären Operator */
         int a, b;
         a = 10;
         b = (a == 1) ? 20 : 30;
         Console.WriteLine("Der Wert von b ist {0}", b);

         b = (a == 10) ? 20 : 30;
         Console.WriteLine("Der Wert von b ist {0}", b);
         Console.ReadLine();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

int 的大小是 4
short 的大小是 2
double 的大小是 8
b 的值是 30
b 的值是 20

Das Schlüsselwort typeof wird verwendet, um das Typobjekt eines Typs abzurufen; es wird häufig für Reflexion und das dynamische Erstellen von Typinstanzen verwendet.

Hier ist ein einfaches Beispiel mit typeof:

Beispiel

using System;

class Program
{
    static void Main(string[] args)
    {
        Type type = typeof(string);
        Console.WriteLine(type.FullName);
        Console.ReadKey();
    }
}

Im obigen Code verwenden wir das Schlüsselwort typeof, um das Typobjekt des Typs string abzurufen und es in einer Variablen type vom Typ Type zu speichern. Dann verwenden wir die Eigenschaft FullName, um den vollqualifizierten Namen dieses Typs auszugeben.

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

System.String

Operatorrangfolge in C#

Die Operatorrangfolge bestimmt die Gruppierung von Termen in einem Ausdruck. Dies beeinflusst, wie ein Ausdruck ausgewertet wird. Einige Operatoren haben eine höhere Rangfolge als andere. Zum Beispiel haben Multiplikations- und Divisionsoperatoren eine höhere Rangfolge als Additions- und Subtraktionsoperatoren.

Zum Beispiel x = 7 + 3 * 2, hier wird x der Wert 13 zugewiesen, nicht 20, weil der Operator * eine höhere Rangfolge als + hat, also wird zuerst die Multiplikation 3*2 berechnet und dann 7 addiert.

Die folgende Tabelle listet Operatoren nach ihrer Operatorrangfolge von hoch bis niedrig auf. Operatoren mit höherer Rangfolge stehen oben in der Tabelle, Operatoren mit niedrigerer Rangfolge unten. In einem Ausdruck werden Operatoren mit höherer Rangfolge zuerst ausgewertet.

Eine einfache Übersicht über die Rangfolge.: Zuerst Klammern, dann Multiplikation/Division, dann Addition/Subtraktion, dann Bitverschiebungen, dann relationale Operatoren, dann logische Operatoren, dann bedingte Operatoren und schließlich das Komma., 。

Kategorie OperatorenAssoziativität
Postfix() [] -> . ++ - -   Von links nach rechts
Unär + - ! ~ ++ - - (type)* & sizeof  Von rechts nach links
Multiplikativ * / % Von links nach rechts
Additiv+ -  Von links nach rechts
Verschiebung << >>  Von links nach rechts
Beziehung< <= > >=  Von links nach rechts
Gleichheit == !=  Von links nach rechts
Bitweises AND&  Von links nach rechts
Bitweises XOR ^  Von links nach rechts
Bitweises OR |  Von links nach rechts
Logisches AND&&  Von links nach rechts
Logisches OR ||  Von links nach rechts
Bedingungen?:  Von rechts nach links
Zuweisung = += -= *= /= %=>>= <<= &= ^= |= Von rechts nach links
comma ,  Von links nach rechts

Beispiel

Beispiel

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(Der Wert von (a + b) * c / d ist {0}, e);

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

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

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

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

(a + b) * c / d 的值是 90
((a + b) * c) / d 的值是 90
(a + b) * (c / d) 的值是 90
a + (b * c) / d 的值是 50

Rangfolge von arithmetischen Operatoren und Zuweisungsoperatoren:

Beispiel

int a = 10, b = 5, c = 2;
int result = a + b * c;  // Zuerst Multiplikation, dann Addition berechnen
Console.WriteLine(result);  // Ausgabe 20

result = (a + b) * c;     // Zuerst die Addition berechnen, dann die Multiplikation
Console.WriteLine(result);  // Ausgabe 30

a += b * c;               // Zuerst die Multiplikation berechnen, dann die Additionszuweisung ausführen
Console.WriteLine(a);       // Ausgabe 20

Rangfolge logischer Operatoren:

Beispiel


bool a = true, b = false, c = true;
bool result = a || b && c;  // Zuerst die UND-Operation berechnen, dann die ODER-Operation
Console.WriteLine(result);  // Ausgabe true

result = (a || b) && c;     // Zuerst die ODER-Operation berechnen, dann die UND-Operation
Console.WriteLine(result);  // Ausgabe true

result = a || (b && c);     // Zuerst die UND-Operation berechnen, dann die ODER-Operation
Console.WriteLine(result);  // Ausgabe true

Rangfolge bedingter Operatoren:

Beispiel

int a = 10, b = 5;
string result = a > b ? "a ist größer als b" : "a ist nicht größer als b";  // Zuerst die Größenbeziehung bestimmen, dann die bedingte Anweisung ausführen
Console.WriteLine(result);  // Ausgabe "a ist größer als b"

Hinweis:Da Klammern die Operatorrangfolge ändern können, wird in der Praxis empfohlen, Klammern so weit wie möglich zu verwenden, um die Reihenfolge der Operationen zu verdeutlichen und die Lesbarkeit und Genauigkeit des Codes zu verbessern.

Weitere Erweiterungen