Jeder kann coden / Programmieren & TicTacToe / C# Einführung / Operatoren Übersicht

Grundlagen weiterer Operatoren¶


Link zur Microsoft Dokumentation Link zum roten Faden auf Miro Link zu Tutorial auf w3schools

1. Gleichheits- und Vergleichsoperatoren¶

Gleichheitsoperator (==): Überprüft, ob zwei Werte gleich sind.
Ungleichheitsoperator (!=): Überprüft, ob zwei Werte ungleich sind.
Vergleichsoperatoren (<, >, <=, >=): Vergleichen zwei Werte.

Beispiel:¶

In [1]:

int a = 5;
int b = 10;

bool gleich = (a == b); // Überprüft, ob a gleich b ist
bool ungleich = (a != b); // Überprüft, ob a ungleich b ist
bool kleiner = (a < b); // Überprüft, ob a kleiner als b ist
bool groesser = (a > b); // Überprüft, ob a größer als b ist
bool kleinerOderGleich = (a <= b); // Überprüft, ob a kleiner oder gleich b ist
bool groesserOderGleich = (a >= b); // Überprüft, ob a größer oder gleich b ist

Ausführliche Erklärung...

Die Gleichheits- und Vergleichsoperatoren in C# ermöglichen es Entwicklern, logische Bedingungen zu überprüfen. Der Gleichheitsoperator (`==`) vergleicht, ob zwei Werte identisch sind, während der Ungleichheitsoperator (`!=`) überprüft, ob sie unterschiedlich sind. Die Vergleichsoperatoren sind nützlich, um numerische Werte zu vergleichen, beispielsweise um festzustellen, ob eine Zahl kleiner oder größer als eine andere ist. Diese Operatoren geben einen booleschen Wert zurück (`true` oder `false`), der in Bedingungen verwendet werden kann, wie etwa in `if`-Anweisungen oder Schleifen.

2. Arithmetische Operatoren¶

Addition (+): Addiert zwei Werte.
Subtraktion (-): Subtrahiert den zweiten Wert vom ersten.
Multiplikation (*): Multipliziert zwei Werte.
Division (/): Teilt den ersten Wert durch den zweiten.
Modulus (%): Gibt den Rest einer Division zurück.
Kurzschreibweisen:
- Addition: +=
- Subtraktion: -=
- Multiplikation: *=
- Division: /=
- Modulus: %=

Beispiel:¶

In [ ]:

int x = 15;
int y = 4;

int summe = x + y; // Addition
int differenz = x - y; // Subtraktion
int produkt = x * y; // Multiplikation
int quotient = x / y; // Division (ganzzahlig)
int rest = x % y; // Modulus

// Kurzschreibweisen
x += 5; // Erhöht x um 5 (x = x + 5)
x -= 2; // Verringert x um 2 (x = x - 2)
x *= 3; // Multipliziert x mit 3 (x = x * 3)
x /= 2; // Teilt x durch 2 (x = x / 2)
x %= 3; // Setzt x auf den Rest von x geteilt durch 3 (x = x % 3)

Ausführliche Erklärung...

Arithmetische Operatoren in C# sind grundlegende Werkzeuge, die es ermöglichen, mathematische Berechnungen durchzuführen. Der Addition-Operator (`+`) addiert zwei Zahlen, während der Subtraktionsoperator (`-`) den zweiten Wert von dem ersten abzieht. Der Multiplikationsoperator (`*`) multipliziert zwei Werte, und der Divisionsoperator (`/`) teilt den ersten Wert durch den zweiten, wobei bei der Ganzzahldivision nur der ganzzahlige Teil des Ergebnisses beibehalten wird. Der Modulus-Operator (`%`) gibt den Rest einer Division zurück und ist nützlich, um festzustellen, ob eine Zahl gerade oder ungerade ist oder um zyklische Berechnungen durchzuführen.

Die Kurzschreibweisen für diese Operatoren ermöglichen es, die Werte in einer kompakten Form zu aktualisieren. Zum Beispiel erhöht x += 5 den aktuellen Wert von x um 5, was dasselbe ist wie x = x + 5. Diese Schreibweise verbessert die Lesbarkeit und reduziert die Codezeilen, die zur Durchführung von Berechnungen erforderlich sind.

3. Schiebeoperatoren¶

Linker Schiebeoperator (<<): Verschiebt die Bits nach links und multipliziert mit 2.
Rechter Schiebeoperator (>>): Verschiebt die Bits nach rechts und dividiert durch 2.

Beispiel:¶

In [ ]:

int zahl = 5; // In Binär: 0000 0101

int links = zahl << 1; // Verschiebt die Bits nach links, ergibt 10 (0000 1010)
int rechts = zahl >> 1; // Verschiebt die Bits nach rechts, ergibt 2 (0000 0010)

Ausführliche Erklärung...

Schiebeoperatoren sind in C# spezielle Operatoren, die mit den Bitdarstellungen von Zahlen arbeiten. Der linke Schiebeoperator (`<<`) verschiebt die Bits einer Zahl nach links, was gleichbedeutend mit einer Multiplikation der Zahl mit 2 ist. Zum Beispiel würde das Verschieben von `5` (in Binär `0000 0101`) nach links um eine Position das Ergebnis `10` (in Binär `0000 1010`) erzeugen. Der rechte Schiebeoperator (`>>`) hingegen verschiebt die Bits nach rechts und entspricht einer Division durch 2. Diese Operatoren sind besonders nützlich in der Systemprogrammierung und bei der Arbeit mit binären Daten.

4. Ternärer Operator¶

Ternärer Operator (? :): Eine Kurzschreibweise für if-else-Anweisungen, die einen Wert basierend auf einer Bedingung zurückgibt.

Beispiel:¶

In [ ]:

int a = 5;
int b = 10;

// Ternärer Operator zur Bestimmung des größeren Wertes
int groesser = (a > b) ? a : b; // Wenn a größer als b ist, wird a zurückgegeben, andernfalls b

Ausführliche Erklärung...

Der ternäre Operator in C# ist eine kompakte Möglichkeit, eine Bedingung zu überprüfen und basierend auf dem Ergebnis einen von zwei Werten zurückzugeben. Der Operator hat die Form `Bedingung ? WertWennWahr : WertWennFalsch`. Wenn die Bedingung `true` ist, wird `WertWennWahr` zurückgegeben, andernfalls wird `WertWennFalsch` zurückgegeben. Dies ermöglicht eine übersichtliche und prägnante Schreibweise, die die Notwendigkeit für eine vollständige `if-else`-Anweisung verringert. Der ternäre Operator ist besonders nützlich in Situationen, in denen eine einfache Bedingungsüberprüfung erforderlich ist.

5. Operatorrangfolge¶

Operatorrangfolge: Bestimmt die Reihenfolge, in der Operatoren in einem Ausdruck ausgewertet werden.

Ausführliche Erklärung...

In C# haben Operatoren unterschiedliche Prioritäten, die festlegen, in welcher Reihenfolge sie in einer Berechnung ausgeführt werden. Operatoren mit höherer Priorität werden vor denen mit niedrigerer Priorität ausgeführt. Zum Beispiel hat der Multiplikationsoperator (`*`) eine höhere Priorität als der Addition-Operator (`+`), sodass in einem Ausdruck wie `3 + 4 * 5` zuerst die Multiplikation und dann die Addition durchgeführt wird, was das Ergebnis `23` ergibt.

Einige der wichtigsten Operatoren in der Rangfolge sind:

Postfix-Operatoren (++, --)
Präfix-Operatoren (++, --, +, -, !, ~)
Multiplikation und Division (*, /, %)
Addition und Subtraktion (+, -)
Vergleichsoperatoren (<, >, <=, >=, ==, !=)
Logische Operatoren (&&, ||)
Zuweisungsoperatoren (=, +=, -=, *=, /=, %=, <<=, >>=, &=, |=, ^=)

Um die Rangfolge von Operatoren besser zu verstehen, ist es hilfreich, Klammern zu verwenden, um die gewünschte Reihenfolge klarzustellen, besonders in komplexen Ausdrücken. Beispielsweise würde 3 + (4 * 5) sicherstellen, dass die Multiplikation zuerst ausgeführt wird, während 3 + 4 * 5 die Multiplikation aufgrund der Rangfolge zuerst durchführt.

← Grundlagen zu Booleschen Operatoren