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

Ganzzahlige numerische Typen¶


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

Übersicht über ganzzahlige numerische Typen¶

C# bietet mehrere ganzzahlige numerische Typen, die ganze Zahlen darstellen. Diese Typen unterscheiden sich in ihrer Größe und ob sie negative Werte darstellen können.

Typ	Größe (Bits)	Bereich	C# Schlüsselwort
`sbyte`	8	-128 bis 127	`sbyte`
`byte`	8	0 bis 255	`byte`
`short`	16	-32.768 bis 32.767	`short`
`ushort`	16	0 bis 65.535	`ushort`
`int`	32	-2.147.483.648 bis 2.147.483.647	`int`
`uint`	32	0 bis 4.294.967.295	`uint`
`long`	64	-9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807	`long`
`ulong`	64	0 bis 18.446.744.073.709.551.615	`ulong`

💡 Praxistipp¶

Wenn ein unsigned int den Wert 0 hat und um 1 dekrementiert wird, tritt ein sogenannter Umbruch oder Wrap-around ein. Das bedeutet, dass der Wert von 0 zum maximal möglichen Wert für diesen Datentyp zurückspringt.

Erklärung des Umbruchs bei `unsigned int`¶

Ein unsigned int (ohne Vorzeichen) kann nur positive Werte und 0 speichern. Nehmen wir an, wir haben einen 32-Bit-unsigned int. Die Werte reichen dann von 0 bis 2^32 - 1 (das ist 4.294.967.295).

Wenn du also 0 um 1 dekrementierst, gibt es keine Möglichkeit, einen negativen Wert zu speichern.
Stattdessen springt der Wert auf das höchste mögliche Ergebnis für diesen Datentyp: 4.294.967.295.

Dies wird als Umbruch bezeichnet, da der Wert wie ein Zähler "um die Null herum" auf den maximal möglichen Wert "umbricht".

Hier ein Beispiel, das zu einem Absturz führt, da durch den Umbruch auf eine Stelle im Array zugegriffen wird, die weit außerhalb des Arrays liegt.

Um das Beispiel zu verstehen, solltest du folgende Kapitel kennen:

Grundlagen weiterer Operatoren →

Bedingte Anweisungen in C# →

Schleifen in C# →

In [8]:

uint zaehler = 5; // Initialisierung eines Integers namens "zaehler" mit dem Wert 5
string test = "ABCDEF"; // Initialisierung einer Zeichenkette (String) "test" mit dem Wert "ABCDEF"
char search = '9'; // Initialisierung einer char-Variable "search" mit dem Zeichen '9'

// Die while-Schleife wird so lange ausgeführt, wie der Wert von "zaehler" größer oder gleich 0 ist.
while (zaehler >= 0) { 
    // Gibt den Index und den aktuellen Wert des Zeichens in der Zeichenkette "test" an der Position "zaehler" aus.
    Console.Write($"test[{zaehler}]:"); 
    Console.WriteLine($"{test[(int)zaehler]}"); // Gibt das Zeichen in "test" an der Stelle "zaehler" aus.
    
    // Überprüft, ob das aktuelle Zeichen in "test" an der Position "zaehler" dem Suchzeichen "search" entspricht.
    if (test[(int)zaehler] == search) { 
        Console.WriteLine("Treffer"); // Gibt "Treffer" aus, wenn das Suchzeichen gefunden wurde.
        break; // Beendet die Schleife, wenn das Suchzeichen gefunden wurde.
    }

    // Verringert den Wert von "zaehler" um 1 und fährt mit der nächsten Iteration der Schleife fort.
    zaehler = zaehler - 1;
}

// Diese Anweisung wird ausgeführt, wenn die Schleife endet (entweder durch das "break" oder weil "zaehler" kleiner als 0 ist).
Console.WriteLine("Ende");

test[5]:F
test[4]:E
test[3]:D
test[2]:C
test[1]:B
test[0]:A
test[4294967295]:

System.IndexOutOfRangeException: Index was outside the bounds of the array.

   at System.String.get_Chars(Int32 index)

   at Submission#9.<<Initialize>>d__0.MoveNext()

--- End of stack trace from previous location ---

   at Microsoft.CodeAnalysis.Scripting.ScriptExecutionState.RunSubmissionsAsync[TResult](ImmutableArray`1 precedingExecutors, Func`2 currentExecutor, StrongBox`1 exceptionHolderOpt, Func`2 catchExceptionOpt, CancellationToken cancellationToken)

Zusammenfassung des Programmablaufs:¶

Der zaehler wird auf den Wert 5 gesetzt, um von der letzten Position der Zeichenkette test zu starten.
Die while-Schleife läuft, bis zaehler negativ wird.
Innerhalb der Schleife wird jedes Zeichen in test an der aktuellen Position ausgegeben.
Falls das Zeichen search (der Wert '9') in test gefunden wird, wird Treffer ausgegeben, und die Schleife wird mit break beendet.
Der Wert von zaehler wird nach jeder Iteration um 1 verringert.
Wenn die Schleife endet, gibt das Programm Ende aus.

Hinweis: Die Schleife führt zu einem Fehler, da zaehler irgendwann auf -1 sinkt, wodurch ein Fehler bei der Indexierung von test entsteht.

Beispiele zur Verwendung¶

sbyte¶

sbyte a = -100;
Console.WriteLine(a);

byte¶

byte b = 255;
Console.WriteLine(b);

short¶

short c = -30000;
Console.WriteLine(c);

ushort¶

ushort d = 65000;
Console.WriteLine(d);

int¶

int e = 2000000000;
Console.WriteLine(e);

uint¶

uint f = 4000000000;
Console.WriteLine(f);

long¶

long g = -9000000000000000000;
Console.WriteLine(g);

ulong¶

ulong h = 18000000000000000000;
Console.WriteLine(h);

Ganzzahlenliterale¶

In C# können ganzzahlige Literale auf verschiedene Arten dargestellt werden:

Dezimal: int x = 123;
Hexadezimal: int y = 0x7B; // 123 in Hexadezimal
Binär: int z = 0b1111011; // 123 in Binär
Oktal: C# unterstützt keine Oktaldarstellung direkt, aber man kann eine Umrechnung vornehmen.

Beispiel für ganzzahlige Literale¶

int dezimal = 123;
int hexadezimal = 0x7B;
int binaer = 0b1111011;
Console.WriteLine(dezimal);
Console.WriteLine(hexadezimal);
Console.WriteLine(binaer);

Konvertierungen¶

In C# können Sie zwischen verschiedenen ganzzahligen Typen konvertieren. Einige Konvertierungen sind implizit (automatisch) und andere erfordern eine explizite Umwandlung:

Implizite Konvertierung: von byte nach int.
Explizite Konvertierung: von int nach byte.

Beispiel für Konvertierungen¶

In [6]:

byte b = 255;
int i = b; // implizite Konvertierung
Console.WriteLine(i);

int j = 300;
byte c = (byte)j; // explizite Konvertierung
Console.WriteLine(c);

255
44

← Wichtige Konzepte im Zusammenhang mit Variablen in C#