Numerische Datentypen

Aus Das Sopra Wiki
Wechseln zu: Navigation, Suche

Bei numerischen Datentypen wird in C# zwischen integralen und Gleitkommatypen unterschieden. Integrale Typen sind alle ganzzahligen Typen wie z.B. int oder long. Gleitkommatypen sind beispielsweise float und double. decimal nimmt dabei eine Sonderstellung ein, da er speziell für finanzmathematische Funktionen vorgesehen ist. Er ist aber ebenfalls ein Gleitkommatyp.

Suffixe

Mit Hilfe von Suffixen kann der genaue Datentyp bei numerischen Werten festgelegt werden. Wird eine Zahl ohne jeglichen Suffix und nicht in Dezimalschreibweise angegeben, so wird diese im Kontext immer als Zahl vom Typ int interpretiert. Eine Zahl in Dezimalschreibweise (zum Beispiel 2.5) ist immer ein double. Dies ist besonders bei mathematischen Operationen innerhalb von Ausdrücken von Bedeutung, da auf diese Weise oftmals Nachkommastellen abgeschnitten werden können.

Beispiel:

Console.WriteLine("Das Ergebnis ist: " + (15 / 2));     // Ausgabe: Das Ergebnis ist: 7
Console.WriteLine("Das Ergebnis ist: " + (15.0 / 2.0)); // Ausgabe: Das Ergebnis ist: 7,5

Um diesem Phänomen vorzubeugen, können an alle numerischen Werte Suffixe angehängt werden, um sie für den Compiler eindeutig einem Typen zuzuordnen. In der folgenden Tabelle sind alle Suffixe und die von ihnen repräsentierten Datentypen aufgelistet.

Suffix Datentyp
D, d Interpretation als double.
F, f Interpretation als float.
L, (l) [1] Interpretation als long.
UL, ul Interpretation als ulong.
M, m Interpretation als decimal.

Wird einer dieser Suffixe an einen numerischen Wert angehängt, wird dieser als der angegebene Datentyp interpretiert. Für das obige Beispiel bedeutet dies:

Console.WriteLine("Das Ergebnis ist: " + (15f / 2f));   // Ausgabe: Das Ergebnis ist: 7,5

Größen

C# kennt von Haus aus unterschiedlichste numerische Datentypen. Die folgende Tabelle soll einen Überblick über die integrierten Datentypen geben. Wichtig sind auch Größe und Wertebereich der unterschiedlichen Typen.

Datentyp Größe Wertebereich Alias
byte 8 Bit <math>0</math> bis <math>255</math> System.Byte
sbyte 8 Bit <math>-128</math> bis <math>127</math> System.SByte
short 16 Bit <math>-32~768</math> bis <math>32~767</math> System.Int16
ushort 16 Bit <math>0</math> bis <math>65~535</math> System.UInt16
int 32 Bit <math>- 2~147~483~648</math> bis <math>2~147~483~647</math> System.Int32
uint 32 Bit <math>0</math> bis <math>4~294~967~295</math> System.UInt32
long 64 Bit <math>-9~223~372~036~854~775~808</math> bis <math>9~223~372~036~854~775~807</math> System.Int64
ulong 64 Bit <math>0</math> bis <math>18~446~744~073~709~551~615</math> System.UInt64
float 32 Bit <math>\pm 1.5 \cdot 10^{45}</math> bis <math>\pm 3.4 \cdot 10^{38}</math> System.Single
double 64 Bit <math>\pm 5.0 \cdot 10^{324}</math> bis <math>\pm 1.7 \cdot 10^{308}</math> System.Double
decimal 128 Bit <math>\pm 1.0 \cdot 10^{28}</math> bis <math>\pm 7.9 \cdot 10^{28}</math> System.Decimal

Umwandlung unter numerischen Datentypen

Beim Umwandeln eines numerischen Datentyps in einen anderen sind grundsätzlich zwei Dinge zu beachten:

  1. Die implizite Umwandlung eines Datentyps mit kleinerem Wertebereich in einen Datentyp mit größerem Wertebereich funktioniert automatisch.
  2. Soll ein Datentyp mit größerem Wertebereich in einen Datentyp mit kleinerem Wertebereich umgewandelt werden, muss explizit gecastet werden.

Das bedeutet im Beispiel:

int i = 100;
long l;

l = i;  // Funktioniert ohne expliziten Cast, da der Wertebereich
        // eines Long (64 Bit) größer ist, als der Wertebereich eines Int (32 Bit)

long lange_zahl = 1234;

int kurze_zahl = (int)lange_zahl;  // Hier muss explizit gecastet werden, da der Wertebereich
                                   // eines Int kleiner ist, als der eines Long.

Zu beachten ist hierbei folgendes: wird explizit gecastet, kann es vorkommen, dass ein Informationsverlust stattfindet. Das bedeutet, wenn ein größerer Datentyp in einen kleineren "gepresst" werden soll, reicht bei großen Zahlen der Wertebereich des kleineren Typs unter Umständen nicht aus, um alle Informationen zu erfassen. Dieses Problem ist häufig eine Quelle von Fehlern. Damit diese fehlerhafte Umwandlung nicht automatisch geschieht, wird vom Programmierer verlangt, die Umwandlung explizit durchzuführen, damit sich der Programmierer im Klaren darüber ist, dass Informationen verloren gehen können.

Referenzen

  1. Hier steht das kleine l in Klammern, da es im Code zu Verwirrungen kommen könnte. Beispiel: Zahlen wie 50001l könnten schnell als 500011 gelesen werden.