C # -Operatoren: Arithmetik, Vergleich, Logik und mehr.

In diesem Artikel erfahren Sie alles über verschiedene Arten von Operatoren in der Programmiersprache C # und deren Verwendung.

Operatoren sind Symbole, mit denen Operationen an Operanden ausgeführt werden. Operanden können Variablen und / oder Konstanten sein.

Zum Beispiel , in 2+3, +ist ein Operator, der zur Durchführung von Additionsoperation verwendet wird, während 2und 3sind Operanden.

Operatoren werden verwendet, um Variablen und Werte in einem Programm zu bearbeiten. C # unterstützt eine Reihe von Operatoren, die basierend auf der Art der von ihnen ausgeführten Operationen klassifiziert werden.

1. Basiszuweisungsoperator

Der grundlegende Zuweisungsoperator (=) wird verwendet, um Variablen Werte zuzuweisen. Beispielsweise,

Doppel-X; x = 50,05;

Hier ist x 50.05 zugeordnet.

Beispiel 1: Basiszuweisungsoperator

 using System; namespace Operator ( class AssignmentOperator ( public static void Main(string() args) ( int firstNumber, secondNumber; // Assigning a constant to variable firstNumber = 10; Console.WriteLine("First Number = (0)", firstNumber); // Assigning a variable to another variable secondNumber = firstNumber; Console.WriteLine("Second Number = (0)", secondNumber); ) ) )

Wenn wir das Programm ausführen, lautet die Ausgabe:

 Erste Zahl = 10 Zweite Zahl = 10

Dies ist ein einfaches Beispiel, das die Verwendung des Zuweisungsoperators demonstriert.

Möglicherweise haben Sie ( )im Beispiel die Verwendung von geschweiften Klammern bemerkt . Wir werden darüber in der String-Formatierung diskutieren. Denken Sie (0)vorerst daran, dass die erste Variable, die auf die Zeichenfolge folgt, (1)durch die zweite Variable usw. ersetzt wird.

2. Arithmetische Operatoren

Arithmetische Operatoren werden verwendet, um arithmetische Operationen wie Addition, Subtraktion, Multiplikation, Division usw. auszuführen.

Beispielsweise,

int x = 5; int y = 10; int z = x + y; // z = 15
C # Arithmetische Operatoren
Operator Name des Bedieners Beispiel
+ Additionsoperator 6 + 3 ergibt 9
- - Subtraktionsoperator 10 - 6 ergibt 4
* * Multiplikationsoperator 4 * 2 ergibt 8
/. Abteilungsbetreiber 10/5 ergibt 2
%. Modulo Operator (Rest) 16% 3 ergibt 1

Beispiel 2: Arithmetische Operatoren

 using System; namespace Operator ( class ArithmeticOperator ( public static void Main(string() args) ( double firstNumber = 14.40, secondNumber = 4.60, result; int num1 = 26, num2 = 4, rem; // Addition operator result = firstNumber + secondNumber; Console.WriteLine("(0) + (1) = (2)", firstNumber, secondNumber, result); // Subtraction operator result = firstNumber - secondNumber; Console.WriteLine("(0) - (1) = (2)", firstNumber, secondNumber, result); // Multiplication operator result = firstNumber * secondNumber; Console.WriteLine("(0) * (1) = (2)", firstNumber, secondNumber, result); // Division operator result = firstNumber / secondNumber; Console.WriteLine("(0) / (1) = (2)", firstNumber, secondNumber, result); // Modulo operator rem = num1 % num2; Console.WriteLine("(0) % (1) = (2)", num1, num2, rem); ) ) )

Wenn wir das Programm ausführen, lautet die Ausgabe:

 14,4 + 4,6 = 19 14,4 - 4,6 = 9,8 14,4 * 4,6 = 66,24 14,4 / 4,6 = 3,1304347826087 26% 4 = 2

Arithmetische Operationen werden im obigen Beispiel ausgeführt. Variablen können in den Anweisungen durch Konstanten ersetzt werden. Beispielsweise,

Ergebnis = 4,5 + 2,7; // Ergebnis enthält 7.2 result = firstNumber - 3.2; // Ergebnis wird 11.2 halten

3. Vergleichsoperatoren

Relationale Operatoren werden verwendet, um die Beziehung zwischen zwei Operanden zu überprüfen. Wenn die Beziehung wahr ist, ist das Ergebnis true, andernfalls führt es zu false.

Relationale Operatoren werden bei der Entscheidungsfindung und bei Schleifen verwendet.

C # -Relationaloperatoren
Operator Name des Bedieners Beispiel
== Gleich 6 == 4 ergibt false
> Größer als 3> -1 ergibt true
< Weniger als 5 <3 ergibt false
> = Größer als oder gleich wie 4> = 4 ergibt true
<= Weniger als oder gleich 5 <= 3 ergibt false
! = Nicht gleichzusetzen mit 10! = 2 ergibt true

Beispiel 3: Vergleichsoperatoren

 using System; namespace Operator ( class RelationalOperator ( public static void Main(string() args) ( bool result; int firstNumber = 10, secondNumber = 20; result = (firstNumber==secondNumber); Console.WriteLine("(0) == (1) returns (2)",firstNumber, secondNumber, result); result = (firstNumber> secondNumber); Console.WriteLine("(0)> (1) returns (2)",firstNumber, secondNumber, result); result = (firstNumber < secondNumber); Console.WriteLine("(0) = secondNumber); Console.WriteLine("(0)>= (1) returns (2)",firstNumber, secondNumber, result); result = (firstNumber <= secondNumber); Console.WriteLine("(0) <= (1) returns (2)",firstNumber, secondNumber, result); result = (firstNumber != secondNumber); Console.WriteLine("(0) != (1) returns (2)",firstNumber, secondNumber, result); ) ) )

Wenn wir das Programm ausführen, lautet die Ausgabe:

 10 == 20 gibt False zurück 10> 20 gibt False zurück 10 = 20 gibt False zurück 10 <= 20 gibt True zurück 10! = 20 gibt True zurück

4. Logische Operatoren

Logische Operatoren werden verwendet logische Operation durchzuführen , wie beispielsweise and, or. Logische Operatoren arbeiten mit booleschen Ausdrücken ( trueund false) und geben boolesche Werte zurück. Logische Operatoren werden bei der Entscheidungsfindung und bei Schleifen verwendet.

So wird das Ergebnis für logische ANDund OROperatoren ausgewertet .

C # Logische Operatoren
Operand 1 Operand 2 ODER (||) UND (&&)
wahr wahr wahr wahr
wahr falsch wahr falsch
falsch wahr wahr falsch
falsch falsch falsch falsch

In einfachen Worten kann die Tabelle wie folgt zusammengefasst werden:

  • Wenn einer der Operanden wahr ist, ORwertet der Operator ihn aus true.
  • Wenn einer der Operanden falsch ist, ANDwertet der Operator ihn aus false.

Beispiel 4: Logische Operatoren

 using System; namespace Operator ( class LogicalOperator ( public static void Main(string() args) ( bool result; int firstNumber = 10, secondNumber = 20; // OR operator result = (firstNumber == secondNumber) || (firstNumber> 5); Console.WriteLine(result); // AND operator result = (firstNumber == secondNumber) && (firstNumber> 5); Console.WriteLine(result); ) ) )

Wenn wir das Programm ausführen, lautet die Ausgabe:

 Wahr falsch

5. Unäre Operatoren

Im Gegensatz zu anderen Operatoren arbeiten die unären Operatoren mit einem einzelnen Operanden.

C # unäre Operatoren
Operator Name des Bedieners Beschreibung
+ Unary Plus Lässt das Zeichen des Operanden unverändert
- - Unary Minus Invertiert das Vorzeichen des Operanden
++ Zuwachs Wert um 1 erhöhen
- - Dekrement Wert um 1 verringern
! Logische Negation (nicht) Invertiert den Wert eines Booleschen Werts

Beispiel 5: Unäre Operatoren

 using System; namespace Operator ( class UnaryOperator ( public static void Main(string() args) ( int number = 10, result; bool flag = true; result = +number; Console.WriteLine("+number = " + result); result = -number; Console.WriteLine("-number = " + result); result = ++number; Console.WriteLine("++number = " + result); result = --number; Console.WriteLine("--number = " + result); Console.WriteLine("!flag = " + (!flag)); ) ) )

Wenn wir das Programm ausführen, lautet die Ausgabe:

 + number = 10 -number = -10 ++ number = 11 --number = 10! flag = False

Die Inkrement- (++)und Dekrementoperatoren (--)können als Präfix und Postfix verwendet werden. Bei Verwendung als Präfix wird die Wertänderung der Variablen in derselben Zeile angezeigt, und bei Verwendung als Postfix wird die Wertänderung der Variablen in der nächsten Zeile angezeigt. Dies wird anhand des folgenden Beispiels deutlich.

Beispiel 6: Post- und Pre-Increment-Operatoren in C #

 using System; namespace Operator ( class UnaryOperator ( public static void Main(string() args) ( int number = 10; Console.WriteLine((number++)); Console.WriteLine((number)); Console.WriteLine((++number)); Console.WriteLine((number)); ) ) )

Wenn wir das Programm ausführen, lautet die Ausgabe:

 10 11 12 12

We can see the effect of using ++ as prefix and postfix. When ++ is used after the operand, the value is first evaluated and then it is incremented by 1. Hence the statement

 Console.WriteLine((number++));

prints 10 instead of 11. After the value is printed, the value of number is incremented by 1.

The process is opposite when ++ is used as prefix. The value is incremented before printing. Hence the statement

 Console.WriteLine((++number));

prints 12.

The case is same for decrement operator (--).

6. Ternary Operator

The ternary operator ? : operates on three operands. It is a shorthand for if-then-else statement. Ternary operator can be used as follows:

 variable = Condition? Expression1 : Expression2;

Der ternäre Operator arbeitet wie folgt:

  • Wenn der durch Bedingung angegebene Ausdruck lautet true, wird das Ergebnis von Ausdruck1 der Variablen zugewiesen.
  • Wenn dies falseder Fall ist , wird das Ergebnis von Expression2 der Variablen zugewiesen.

Beispiel 7: Ternärer Operator

 using System; namespace Operator ( class TernaryOperator ( public static void Main(string() args) ( int number = 10; string result; result = (number % 2 == 0)? "Even Number" : "Odd Number"; Console.WriteLine("(0) is (1)", number, result); ) ) )

Wenn wir das Programm ausführen, lautet die Ausgabe:

 10 ist gerade Zahl

Weitere Informationen erhalten Sie unter C # ternary operator.

7. Bitweise und Bitverschiebungsoperatoren

Bitweise und Bitverschiebungsoperatoren werden verwendet, um Bitmanipulationsoperationen durchzuführen.

C # Bitweise und Bitverschiebungsoperatoren
Operator Name des Bedieners
~ Bitweise Ergänzung
& Bitweises UND
| Bitweises ODER
^ Bitweises exklusives ODER
<< Bitweise Linksverschiebung
>> Bitweise Rechtsverschiebung

Beispiel 8: Bitweiser und Bitverschiebungsoperator

 using System; namespace Operator ( class BitOperator ( public static void Main(string() args) ( int firstNumber = 10; int secondNumber = 20; int result; result = ~firstNumber; Console.WriteLine("~(0) = (1)", firstNumber, result); result = firstNumber & secondNumber; Console.WriteLine("(0) & (1) = (2)", firstNumber,secondNumber, result); result = firstNumber | secondNumber; Console.WriteLine("(0) | (1) = (2)", firstNumber,secondNumber, result); result = firstNumber secondNumber; Console.WriteLine("(0) (1) = (2)", firstNumber,secondNumber, result); result = firstNumber << 2; Console.WriteLine("(0) <> 2; Console.WriteLine("(0)>> 2 = (1)", firstNumber, result); ) ) )

Wenn wir das Programm ausführen, lautet die Ausgabe:

~ 10 = -11 10 & 20 = 0 10 | 20 = 30 10 20 = 30 10 2 = 2

Weitere Informationen finden Sie unter C # Bitwise und Bit Shift Operator.

8. Compound Assignment Operators

C # Compound Assignment Operators
Operator Name des Bedieners Beispiel Gleichwertig
+ = Zusatzzuordnung x += 5 x = x + 5
- = Subtraktionszuordnung x -= 5 x = x - 5
* = Multiplikationszuweisung x *= 5 x = x * 5
/ = Abteilungszuordnung x /= 5 x = x / 5
% = Modulo-Zuordnung x %= 5 x = x % 5
& = Bitweise UND Zuordnung x &= 5 x = x & 5
| = Bitweise ODER Zuordnung x |= 5 x = x | 5
= Bitweise XOR-Zuordnung x ^= 5 x = x 5
<< = Zuordnung der linken Schicht x <<= 5 x = x << 5
>> = Rechtsverschiebung x>>= 5 x = x>> 5
=> Lambda-Betreiber x => x*x Returns x*x

Beispiel 9: Compound Assignment Operator

 using System; namespace Operator ( class BitOperator ( public static void Main(string() args) ( int number = 10; number += 5; Console.WriteLine(number); number -= 3; Console.WriteLine(number); number *= 2; Console.WriteLine(number); number /= 3; Console.WriteLine(number); number %= 3; Console.WriteLine(number); number &= 10; Console.WriteLine(number); number |= 14; Console.WriteLine(number); number ^= 12; Console.WriteLine(number); number <>= 3; Console.WriteLine(number); ) ) )

Wenn wir das Programm ausführen, lautet die Ausgabe:

 15 12 24 8 2 2 14 2 8 1

Wir werden in einem späteren Tutorial über Lambda-Operatoren sprechen.

Interessante Beiträge...