Operatoren sind die Grundlage jeder Programmiersprache. Somit ist die Funktionalität von C# Ohne die Verwendung von Operatoren ist die Sprache unvollständig. Mithilfe von Operatoren können wir verschiedene Arten von Operationen durchführen Operanden . In C# , Operatoren können kategorisiert werden basierend auf ihre unterschiedlich Funktionalität :

• Rechenzeichen
• Vergleichsoperatoren
• Logische Operatoren
• Bitweise Operatoren
• Zuweisungsoperatoren
• Bedingter Operator

In C# können Operatoren auch kategorisiert werden basierend auf der Anzahl der Operanden:

• Unärer Operator: Betreiber, der braucht eins Operand zum Ausführen der Operation.
• Binärer Operator: Betreiber, der dauert zwei Operanden zum Ausführen der Operation.
• Ternärer Operator: Betreiber, der dauert drei Operanden zum Ausführen der Operation.
  

Rechenzeichen

Diese werden verwendet, um arithmetische/mathematische Operationen an Operanden durchzuführen. Der Binäre Operatoren In diese Kategorie fallen:

Javascript-Onload-Skript

• Zusatz: Der '+' Der Operator fügt zwei Operanden hinzu. Zum Beispiel, x+y .
• Subtraktion: Der '-' Der Operator subtrahiert zwei Operanden. Zum Beispiel, x-y .
• Multiplikation: Der '*' Operator multipliziert zwei Operanden. Zum Beispiel, x*y .
• Aufteilung: Der '/' Der Operator dividiert den ersten Operanden durch den zweiten. Zum Beispiel, x/y .
• Modul: Der '%' Der Operator gibt den Rest zurück, wenn der erste Operand durch den zweiten geteilt wird. Zum Beispiel, x%y .

Beispiel:

// C# program to demonstrate the working  // of Binary Arithmetic Operators using System; namespace Arithmetic {  class GFG  {    // Main Function  static void Main(string[] args)  {    int result;  int x = 10, y = 5;    // Addition  result = (x + y);  Console.WriteLine('Addition Operator: ' + result);    // Subtraction  result = (x - y);  Console.WriteLine('Subtraction Operator: ' + result);    // Multiplication  result = (x * y);  Console.WriteLine('Multiplication Operator: '+ result);    // Division  result = (x / y);  Console.WriteLine('Division Operator: ' + result);    // Modulo  result = (x % y);  Console.WriteLine('Modulo Operator: ' + result);  }  } }>

Ausgabe:

Addition Operator: 15 Subtraction Operator: 5 Multiplication Operator: 50 Division Operator: 2 Modulo Operator: 0>

Diejenigen, die in die Kategorie fallen Unäre Operatoren Sind:

• Zuwachs: Der '++' Der Operator wird verwendet, um den Wert einer Ganzzahl zu erhöhen. Bei Platzierung vor dem Variablennamen (auch genannt Vorinkrement Operator) wird sein Wert sofort erhöht. Zum Beispiel, ++x .
  Und wenn es nach dem Variablennamen (auch genannt) platziert wird Post-Inkrement-Operator ), bleibt sein Wert vorübergehend bis zur Ausführung dieser Anweisung erhalten und wird vor der Ausführung der nächsten Anweisung aktualisiert. Zum Beispiel, x++ .
• Dekrementieren: Der '- -' Der Operator wird verwendet, um den Wert einer Ganzzahl zu dekrementieren. Bei Platzierung vor dem Variablennamen (auch genannt Vor-Dekrement-Operator ), wird sein Wert sofort verringert. Zum Beispiel, - -X .
  Und wenn es nach dem Variablennamen (auch genannt) platziert wird Post-Dekrement-Operator ), bleibt sein Wert vorübergehend bis zur Ausführung dieser Anweisung erhalten und wird vor der Ausführung der nächsten Anweisung aktualisiert. Zum Beispiel, X- - .

Beispiel:

// C# program to demonstrate the working  // of Unary Arithmetic Operators using System; namespace Arithmetic {    class GFG {    // Main Function  static void Main(string[] args)  {    int a = 10, res;    // post-increment example:  // res is assigned 10 only,   // a is not updated yet  res = a++;    //a becomes 11 now  Console.WriteLine('a is {0} and res is {1}', a, res);      // post-decrement example:  // res is assigned 11 only, a is not updated yet  res = a--;    //a becomes 10 now  Console.WriteLine('a is {0} and res is {1}', a, res);       // pre-increment example:  // res is assigned 11 now since a  // is updated here itself  res = ++a;    // a and res have same values = 11  Console.WriteLine('a is {0} and res is {1}', a, res);      // pre-decrement example:  // res is assigned 10 only since  // a is updated here itself  res = --a;    // a and res have same values = 10  Console.WriteLine('a is {0} and res is {1}',a, res);       }  } }>

Ausgabe:

a is 11 and res is 10 a is 10 and res is 11 a is 11 and res is 11 a is 10 and res is 10>

Vergleichsoperatoren

Vergleichsoperatoren werden zum Vergleich zweier Werte verwendet. Sehen wir sie uns einzeln an:

• '=='(Gleich) Der Operator prüft, ob die beiden angegebenen Operanden gleich sind oder nicht. Wenn ja, wird true zurückgegeben. Andernfalls wird false zurückgegeben. Zum Beispiel, 5==5 wird true zurückgeben.
• '!='(Ungleich) Der Operator prüft, ob die beiden angegebenen Operanden gleich sind oder nicht. Wenn nicht, wird true zurückgegeben. Andernfalls wird false zurückgegeben. Es ist das genaue boolesche Komplement von '==' Operator. Zum Beispiel, 5!=5 wird false zurückgeben.
• '>'(Größer als) Der Operator prüft, ob der erste Operand größer als der zweite Operand ist. Wenn ja, wird true zurückgegeben. Andernfalls wird false zurückgegeben. Zum Beispiel, 6>5 wird true zurückgeben.
• „<“ (Kleiner als) Der Operator prüft, ob der erste Operand kleiner als der zweite Operand ist. Wenn ja, wird true zurückgegeben. Andernfalls wird false zurückgegeben. Zum Beispiel, 6<5 wird false zurückgeben.
• '>='(Größer als gleich) Der Operator prüft, ob der erste Operand größer oder gleich dem zweiten Operanden ist. Wenn ja, wird true zurückgegeben. Andernfalls wird false zurückgegeben. Zum Beispiel, 5>=5 wird true zurückgeben.
• '<='(Kleiner als gleich) Der Operator prüft, ob der erste Operand kleiner oder gleich dem zweiten Operanden ist. Wenn ja, wird true zurückgegeben. Andernfalls wird false zurückgegeben. Zum Beispiel, 5<=5 wird auch true zurückgeben.

Beispiel:

// C# program to demonstrate the working  // of Relational Operators using System; namespace Relational {   class GFG {    // Main Function  static void Main(string[] args)  {  bool result;  int x = 5, y = 10;    // Equal to Operator  result = (x == y);  Console.WriteLine('Equal to Operator: ' + result);    // Greater than Operator  result = (x>y);  Console.WriteLine('Größer als Operator: ' + Ergebnis);    // Kleiner als Operatorergebnis = (x< y);  Console.WriteLine('Less than Operator: ' + result);    // Greater than Equal to Operator  result = (x>= y);  Console.WriteLine('Größer als oder gleich: '+ Ergebnis);    // Kleiner als gleich Operatorergebnis = (x<= y);  Console.WriteLine('Lesser than or Equal to: '+ result);    // Not Equal To Operator  result = (x != y);  Console.WriteLine('Not Equal to Operator: ' + result);  } } }>

Ausgabe:

Equal to Operator: False Greater than Operator: False Less than Operator: True Greater than or Equal to: False Lesser than or Equal to: True Not Equal to Operator: True>

Logische Operatoren

Sie werden verwendet, um zwei oder mehr Bedingungen/Einschränkungen zu kombinieren oder die Bewertung der betrachteten ursprünglichen Bedingung zu ergänzen. Sie werden im Folgenden beschrieben:

• Logisches UND: Der '&&' Der Operator gibt true zurück, wenn beide berücksichtigten Bedingungen erfüllt sind. Andernfalls wird false zurückgegeben. Zum Beispiel, a && b gibt true zurück, wenn sowohl a als auch b wahr sind (d. h. ungleich Null).
• Logisches ODER: Der '||' Der Operator gibt „true“ zurück, wenn eine (oder beide) der betrachteten Bedingungen erfüllt sind. Andernfalls wird false zurückgegeben. Zum Beispiel, ein || B gibt true zurück, wenn eines von a oder b wahr ist (d. h. ungleich Null). Natürlich gibt es true zurück, wenn sowohl a als auch b true sind.
• Logisches NICHT: Der '!' Der Operator gibt „true“ zurück, die betrachtete Bedingung ist nicht erfüllt. Andernfalls wird false zurückgegeben. Zum Beispiel, !A gibt true zurück, wenn a falsch ist, d. h. wenn a=0.

Beispiel:

// C# program to demonstrate the working  // of Logical Operators using System; namespace Logical {   class GFG {    // Main Function  static void Main(string[] args)   } }>

Ausgabe:

AND Operator: False OR Operator: True NOT Operator: False>

Bitweise Operatoren

In C# gibt es 6 bitweise Operatoren, die auf Bitebene arbeiten oder zur Durchführung bitweiser Operationen verwendet werden. Im Folgenden sind die bitweisen Operatoren aufgeführt:

• & (bitweises UND) Nimmt zwei Zahlen als Operanden und führt eine UND-Verknüpfung für jedes Bit zweier Zahlen durch. Das Ergebnis von AND ist nur dann 1, wenn beide Bits 1 sind.
• | (bitweises ODER) Nimmt zwei Zahlen als Operanden und führt eine ODER-Verknüpfung für jedes Bit zweier Zahlen durch. Das Ergebnis von OR ist 1, jedes der beiden Bits ist 1.
• ^ (bitweises XOR) Nimmt zwei Zahlen als Operanden und führt eine XOR-Verknüpfung für jedes Bit zweier Zahlen durch. Das Ergebnis von XOR ist 1, wenn die beiden Bits unterschiedlich sind.
• ~ (bitweises Komplement) Nimmt eine Zahl als Operanden und invertiert jedes Bit, also 1 zu 0 und 0 zu 1.
• << (Linksverschiebung) Nimmt zwei Zahlen, verschiebt die Bits des ersten Operanden nach links, der zweite Operand bestimmt die Anzahl der zu verschiebenden Stellen.
• >> (Rechtsverschiebung) Nimmt zwei Zahlen, verschiebt die Bits des ersten Operanden nach rechts, der zweite Operand bestimmt die Anzahl der zu verschiebenden Stellen.

Beispiel:

// C# program to demonstrate the working  // of Bitwise Operators using System; namespace Bitwise {   class GFG {    // Main Function  static void Main(string[] args)    int x = 5, y = 10, result;    // Bitwise AND Operator  result = x & y;  Console.WriteLine('Bitwise AND: ' + result);    // Bitwise OR Operator  result = x  } }>

Ausgabe:

Bitwise AND: 0 Bitwise OR: 15 Bitwise XOR: 15 Bitwise Complement: -6 Bitwise Left Shift: 20 Bitwise Right Shift: 1>

Zuweisungsoperatoren

Zuweisungsoperatoren werden verwendet, um einer Variablen einen Wert zuzuweisen. Der linke Operand des Zuweisungsoperators ist eine Variable und der rechte Operand des Zuweisungsoperators ist ein Wert. Der Wert auf der rechten Seite muss vom gleichen Datentyp sein wie die Variable auf der linken Seite, andernfalls gibt der Compiler einen Fehler aus.

Im Folgenden sind verschiedene Arten von Zuweisungsoperatoren aufgeführt:

• =(Einfache Aufgabe) : Dies ist der einfachste Zuweisungsoperator. Mit diesem Operator wird der Wert rechts der Variablen links zugewiesen.
  Beispiel:

a = 10; b = 20; ch = 'y';>

• +=(Aufgabe hinzufügen) : Dieser Operator ist eine Kombination aus den Operatoren „+“ und „=“. Dieser Operator addiert zunächst den aktuellen Wert der Variablen links zum Wert rechts und weist das Ergebnis dann der Variablen links zu.
  Beispiel:

(a += b) can be written as (a = a + b)>

Wenn der ursprünglich in a gespeicherte Wert 5 ist, dann ist (a += 6) = 11.

• -=(Aufgabe subtrahieren) : Dieser Operator ist eine Kombination aus den Operatoren „-“ und „=“. Dieser Operator subtrahiert zunächst den aktuellen Wert der Variablen links vom Wert rechts und weist das Ergebnis dann der Variablen links zu.
  Beispiel:

(a -= b) can be written as (a = a - b)>

Wenn der ursprünglich in a gespeicherte Wert 8 ist, dann ist (a -= 6) = 2.

• *=(Zuweisung multiplizieren) : Dieser Operator ist eine Kombination aus den Operatoren „*“ und „=“. Dieser Operator multipliziert zunächst den aktuellen Wert der Variablen links mit dem Wert rechts und weist das Ergebnis dann der Variablen links zu.
  Beispiel:

(a *= b) can be written as (a = a * b)>

Wenn der ursprünglich in a gespeicherte Wert 5 ist, dann ist (a *= 6) = 30.

• /=(Abteilungszuordnung): Dieser Operator ist eine Kombination aus den Operatoren „/“ und „=“. Dieser Operator dividiert zunächst den aktuellen Wert der Variablen links durch den Wert rechts und weist das Ergebnis dann der Variablen links zu.
  Beispiel:

(a /= b) can be written as (a = a / b)>

Wenn der ursprünglich in a gespeicherte Wert 6 ist, dann ist (a /= 2) = 3.

• %=(Modulzuweisung): Dieser Operator ist eine Kombination aus den Operatoren „%“ und „=“. Dieser Operator moduliert zunächst den aktuellen Wert der Variablen links durch den Wert rechts und weist das Ergebnis dann der Variablen links zu.
  Beispiel:

(a %= b) can be written as (a = a % b)>

Wenn der ursprünglich in a gespeicherte Wert 6 ist, dann ist (a %= 2) = 0.

• <<=(Linksschichtzuweisung) : Dieser Operator ist eine Kombination aus den Operatoren „<<“ und „=“. Dieser Operator verschiebt zunächst den aktuellen Wert der Variablen links um den Wert rechts nach links und weist das Ergebnis dann der Variablen links zu.
  Beispiel:

(a <<= 2) can be written as (a = a << 2)>

Wenn der ursprünglich in a gespeicherte Wert 6 ist, dann ist (a <<= 2) = 24.

• >>=(Rechtsverschiebungszuweisung) : Dieser Operator ist eine Kombination aus den Operatoren „>>“ und „=“. Dieser Operator verschiebt zunächst den aktuellen Wert der Variablen links um den Wert rechts nach rechts und weist das Ergebnis dann der Variablen links zu.
  Beispiel:

(a>>= 2) kann geschrieben werden als (a = a>> 2)>

Wenn der ursprünglich in a gespeicherte Wert 6 ist, dann ist (a>>= 2) = 1.

• &=(Bitweise UND-Zuweisung) : Dieser Operator ist eine Kombination aus den Operatoren „&“ und „=“. Dieser Operator verknüpft zunächst bitweise den aktuellen Wert der Variablen auf der linken Seite mit dem Wert auf der rechten Seite und weist das Ergebnis dann der Variablen auf der linken Seite zu.
  Beispiel:

(a &= 2) can be written as (a = a & 2)>

Wenn der ursprünglich in a gespeicherte Wert 6 ist, dann ist (a &= 2) = 2.

• ^=(Bitweises Exklusiv-ODER) : Dieser Operator ist eine Kombination aus den Operatoren „^“ und „=“. Dieser Operator verknüpft zunächst bitweise Exklusiv-ODER den aktuellen Wert der Variablen auf der linken Seite mit dem Wert auf der rechten Seite und weist das Ergebnis dann der Variablen auf der linken Seite zu.
  Beispiel:

(a ^= 2) can be written as (a = a ^ 2)>

Wenn der ursprünglich in a gespeicherte Wert 6 ist, dann ist (a ^= 2) = 4.

• |=(Bitweises inklusives ODER) : Dieser Operator ist eine Kombination aus den Operatoren „|“ und „=“. Dieser Operator führt zunächst eine bitweise inklusive ODER-Verknüpfung des aktuellen Werts der Variablen links mit dem Wert rechts durch und weist das Ergebnis dann der Variablen links zu.
  Beispiel :

(a |= 2) can be written as (a = a | 2)>

Wenn anfänglich der in a gespeicherte Wert 6 ist. Dann ist (a |= 2) = 6.

Beispiel:

// C# program to demonstrate the working  // of Assignment Operators using System; namespace Assignment {   class GFG {    // Main Function  static void Main(string[] args)  = 4;   Console.WriteLine('Bitwise Inclusive OR Assignment Operator: ' + x);     } }>

Ausgabe :

Add Assignment Operator: 25 Subtract Assignment Operator: 15 Multiply Assignment Operator: 75 Division Assignment Operator: 5 Modulo Assignment Operator: 0 Left Shift Assignment Operator: 32 Right Shift Assignment Operator: 2 Bitwise AND Assignment Operator: 4 Bitwise Exclusive OR Assignment Operator: 8 Bitwise Inclusive OR Assignment Operator: 12>

Bedingter Operator

Es handelt sich um einen ternären Operator, der eine Kurzform der if-else-Anweisung ist. Es hat drei Operanden und daher der Name Ternär. Abhängig vom Wert eines booleschen Ausdrucks wird einer von zwei Werten zurückgegeben.

Syntax:

condition ? first_expression : second_expression;>

Erläuterung:
Bedingung: Es muss als wahr oder falsch ausgewertet werden.
Wenn die Bedingung wahr ist
first_expression wird ausgewertet und zum Ergebnis.
Wenn die Bedingung falsch ist,
second_expression wird ausgewertet und zum Ergebnis.

Beispiel:

// C# program to demonstrate the working  // of Conditional Operator using System; namespace Conditional {   class GFG {    // Main Function  static void Main(string[] args)  {  int x = 5, y = 10, result;    // To find which value is greater  // Using Conditional Operator  result = x>ja? x : y;     // Um ​​das Ergebnis anzuzeigen Console.WriteLine('Result: ' + result);    // Um ​​herauszufinden, welcher Wert größer ist // Verwenden des bedingten Operators result = x< y ? x : y;     // To display the result  Console.WriteLine('Result: ' + result);  } } }>

Ausgabe :

Numpy-Punkt

Result: 10 Result: 5>