C# 7.0 - kurz & gut
von: Joseph Albahari, Ben Albahari
O'Reilly Verlag, 2018
ISBN: 9783960101758
Sprache: Deutsch
238 Seiten, Download: 867 KB
Format: EPUB, auch als Online-Lesen
Numerische Typen
C# bietet die folgenden vordefinierten numerischen Typen:
| C#-Typ | Systemtyp | Suffix | Breite | Bereich |
| Ganzzahlig mit Vorzeichen |
| sbyte | SByte |
| 8 Bit | –27 bis 27 – 1 |
| short | Int16 |
| 16 Bit | –215 bis 215 – 1 |
| int | Int32 |
| 32 Bit | –231 bis 231 – 1 |
| long | Int64 | L | 64 Bit | –263 bis 263 – 1 |
| Ganzzahlig ohne Vorzeichen |
| byte | Byte |
| 8 Bit | 0 bis 28 – 1 |
| ushort | UInt16 |
| 16 Bit | 0 bis 216 – 1 |
| uint | UInt32 | U | 32 Bit | 0 bis 232 – 1 |
| ulong | UInt64 | UL | 64 Bit | 0 bis 264 – 1 |
| Reell |
| float | Single | F | 32 Bit | ± (~10–45 bis 1038) |
| double | Double | D | 64 Bit | ± (~10–324 bis 10308) |
| decimal | Decimal | M | 128 Bit | ± (~10–28 bis 1028) |
Von den ganzzahligen Typen sind int und long Bürger erster Klasse und werden von C# und der Runtime bevorzugt. Die anderen ganzzahligen Typen werden üblicherweise im Dienste der Interoperabilität eingesetzt oder wenn eine effiziente Speicherplatznutzung wichtig ist.
Von den reellen Zahltypen werden float und double auch als Gleitkommatypen bezeichnet und üblicherweise für wissenschaftliche Berechnungen sowie im Grafikumfeld genutzt. Der Typ decimal wird in der Regel für finanzmathematische Berechnungen verwendet, bei denen eine exakte Basis-10-Arithmetik und hohe Genauigkeit erforderlich sind. (Technisch betrachtet, ist decimal ebenfalls ein Gleitkommatyp, wird normalerweise aber nicht als solcher bezeichnet.)
Numerische Literale
Ganzzahlliterale können mit der Dezimal- oder der Hexadezimalnotation dargestellt werden; die Hexadezimalnotation wird mit dem Präfix 0x angezeigt (z. B. entspricht 0x7f dem Dezimalwert 127). Seit C# 7.0 können Sie auch das Präfix 0b für Binärliterale einsetzen. Reelle Literale können die Dezimal- oder die Exponentialnotation nutzen, z. B. 1E06.
Ab C# 7.0 können numerische Literale für eine bessere Lesbarkeit durch Unterstriche ergänzt werden (zum Beispiel 1_000_000).
Typableitung bei numerischen Literalen
Standardmäßig geht der Compiler davon aus, dass ein numerisches Literal entweder einen double-Wert oder einen ganzzahligen Wert darstellt:
- Wenn das Literal einen Dezimaltrenner oder das Exponential-symbol (E) enthält, ist der Typ double.
- Andernfalls ist der Typ des Literals der erste Typ aus der folgenden Liste, in den der Wert des Literals passt: int, uint, long und ulong.
Hier sehen Sie Beispiele dafür:
Console.Write ( 1.0.GetType()); // Double (double)
Console.Write ( 1E06.GetType()); // Double (double)
Console.Write ( 1.GetType()); // Int32 (int)
Console.Write ( 0xF0000000.GetType()); // UInt32 (uint)
Console.Write (0x100000000.GetType()); // Int64 (long)
Numerische Suffixe
Die numerischen Suffixe, die in der vorangegangenen Tabelle aufgeführt sind, definieren den Typ eines Literals:
decimal d = 3.5M; // M = decimal (ignoriert Groß-/Kleinschrei-
// bung)
Die Suffixe U und L werden nur selten benötigt, weil die Typen uint, long und ulong fast immer erschlossen werden können oder int implizit in sie umgewandelt werden kann.
long i = 5; // implizite Umwandlung von int in long
Das Suffix D ist technisch gesehen redundant, da bei allen Literalen, die einen Dezimaltrenner enthalten, geschlossen wird, dass es double-Werte sind (und man einem numerischen Literal immer einen Dezimaltrenner anhängen kann). Die Suffixe F und M sind am nützlichsten und außerdem unumgänglich, wenn man float- oder decimal-Literale angeben will. Ohne Suffixe ließen sich die folgenden Anweisungen nicht kompilieren, da geschlossen würde, dass 4.5 den Typ double hat, der sich nicht implizit in float oder decimal umwandeln lässt.
float f = 4.5F; // kompiliert ohne Suffix nicht
decimal d = 4.5M; // kompiliert ohne Suffix nicht
Numerische Umwandlung
Ganzzahlige Umwandlungen
Ganzzahlige Umwandlungen sind implizit, wenn der Zieltyp jeden möglichen Wert des Ausgangstyps darstellen kann. Andernfalls ist eine explizite Umwandlung erforderlich, zum Beispiel so:
int x = 12345; // int ist ein 32-Bit-Wert
long y = x; // implizite Umwandlung in einen 64-Bit-int
short z = (short)x; // explizite Umwandlung in einen 16-Bit-int
Reelle Umwandlungen
Ein float kann implizit in einen double umgewandelt werden, weil ein double jeden möglichen float-Wert darstellen kann. Die umgekehrte Umwandlung muss explizit sein.
Die Umwandlung zwischen decimal und den anderen reellen Typen muss explizit sein.
Reelle Typen in ganzzahlige Typen umwandeln
Die Umwandlung eines ganzzahligen Typs in einen reellen Typ ist immer implizit, während die umgekehrte Umwandlung immer explizit angegeben werden muss. Bei der Umwandlung eines Gleitkommatyps in einen ganzzahligen Typ wird immer der möglicherweise vorhandene Nachkommateil der Zahl abgeschnitten. Rundende Umwandlungen können Sie mit der statischen Klasse System.Convert durchführen.
Ein Nachteil der impliziten Umwandlung ist, dass bei der Umwandlung großer ganzzahlige Werte in Gleitkommawerte zwar die Größenordnung erhalten bleibt, gelegentlich aber Genauigkeit verloren geht.
int i1 = 100000001;
float f = i1; // Größe bleibt erhalten, Genauigkeit ver-
// schwindet
int i2 = (int)f; //...