Einführung in Dezimalzahlen und den Typ double

1. Dezimalzahlen

Erinnern wir uns an unser Projekt – nehmen wir an, es ist ein ganz einfacher Taschenrechner. Oder irgendein Programm, wo gerechnet werden muss (vom banalen Geldzählen bis hin zu komplexer Physik). Nicht alles im echten Leben ist eine ganze Zahl, und das kann man nicht ändern!

Also schnappen wir uns einen neuen Datentyp!

In der Programmierung nennt man Dezimalzahlen auch reelle Zahlen oder Gleitkommazahlen (floating-point). In C#, wie in den meisten Sprachen, braucht man sie, um nicht nur ganze, sondern auch "gebrochene" Werte zu speichern: so was wie 3.14, -28.57, 2.718281828...

Reelle Zahlen gibt es in zwei Haupttypen:

float

double

Typ float

Der Typ float hat seinen Namen von floating-point number – Gleitkommazahl. Reelle Zahlen sind mathematische Zahlen mit bestimmten Eigenschaften. Aber Computer haben viele Einschränkungen. Deshalb ist es nicht ganz korrekt, Dezimalzahlen in C# als reelle Zahlen zu bezeichnen. Dafür wird der Name "Gleitkommazahlen" verwendet.

Der Typ float speichert normalerweise 7 signifikante Stellen (zum Beispiel 0.1234567), eine Zehnerpotenz und belegt 4 Byte im Speicher. Das ist ziemlich wenig für genaue Berechnungen, deshalb sind alle schnell zu double gewechselt.

2. Deklaration und Initialisierung von Variablen vom Typ double

Alles wie bei int – nur dass wir jetzt double verwenden.

// Variable deklarieren und ihr den Wert von Pi zuweisen
double pi = 3.1415926;

// Man kann auch ohne Initialisierung deklarieren
double durchschnittsGehalt;
durchschnittsGehalt = 91234.56;

// Man kann auch rechnen!
double pizzaStuecke = 8;
double freunde = 3;
double stueckeProFreund = pizzaStuecke / freunde; // 2.666... (und nicht 2)

Syntax-Besonderheiten:

• Als Dezimaltrennzeichen wird der Punkt (3.14) verwendet. Wenn du ein Komma benutzt, gibt's einen Compilerfehler!
• Genau genommen bekommst du keinen Fehler, wenn du double d = 3; schreibst – die Typen werden automatisch konvertiert (die ganze Zahl wird verlustfrei zur "Gleitkommazahl").

3. Ein- und Ausgabe von Gleitkommazahlen mit Console

Probieren wir zuerst, eine Dezimalzahl auszugeben:

double betrag = 42.75;
Console.WriteLine(betrag); // Gibt aus: 42.75

Alles gut! Und wenn wir Text hinzufügen:

Console.WriteLine("Auf deinem Konto: " + betrag + " Euro."); // Auf deinem Konto: 42.75 Euro.

Eingabe von der Tastatur

Das Wichtigste: Console.ReadLine() gibt immer einen String zurück, du musst ihn zu double konvertieren.

Console.WriteLine("Gib die Temperatur draußen ein:");
string eingabe = Console.ReadLine();
double temperatur = double.Parse(eingabe); // String zu double konvertieren

Console.WriteLine("Draußen sind es jetzt: " + temperatur + " Grad.");

4. Typ double in Aktion: Arithmetik

Alle gewohnten Operatoren (+, -, *, /) funktionieren wie bei int:

double distanz = 100.5;
double zeit = 2.0;
double geschwindigkeit = distanz / zeit; // 50.25

Console.WriteLine("Durchschnittsgeschwindigkeit: " + geschwindigkeit); // Durchschnittsgeschwindigkeit: 50.25

Das war schon die ganze Arithmetik. Der einzige Unterschied: Das Ergebnis einer Division ist immer eine Dezimalzahl, wenn mindestens einer der Operanden ein double ist.

Vergleich mit int

int a = 5, b = 2;
Console.WriteLine(a / b); // 2 (Rest wird abgeschnitten)

double aa = 5, bb = 2;
Console.WriteLine(aa / bb); // 2.5

5. Typische Fehler und Merkwürdigkeiten bei double

Fehler bei der String-Konvertierung

Klassische Situation: Der User gibt 3,14 ein – aber das Programm erwartet 3.14.

// Das gibt einen Fehler, wenn "3,14" eingegeben wird
double wert = double.Parse(Console.ReadLine());

Wenn du das Programm in Ländern nutzt, wo das Komma das Dezimaltrennzeichen ist (z.B. Polen, Deutschland), dann funktioniert double.Parse normal. Aber wenn die App mit "englischen" Einstellungen läuft, wird ein Punkt erwartet.

Fehler durch "Ungenauigkeit" von Zahlen im Computer

Hier wundern sich Anfänger meistens ein bisschen:

double x = 0.1 + 0.2;
Console.WriteLine(x); // Hm... 0.30000000000000004

Glückwunsch, du bist auf die "Magie" der Darstellung von Dezimalzahlen im Computer gestoßen. Viele Zahlen lassen sich im Binärsystem einfach nicht exakt darstellen. Mehr dazu in der nächsten Vorlesung – jetzt erstmal keine Panik! Für die meisten Anwendungen ist das nicht kritisch, aber in Finanzen und exakten Wissenschaften gibt's Besonderheiten.

6. Wichtig: double und int – automatische und explizite Konvertierung

Manchmal addierst du eine ganze und eine Dezimalzahl oder weist einer double-Variable einen int zu – das gibt keinen Fehler:

int i = 2;
double d = i; // Alles ok!
Console.WriteLine(d); // 2

double dd = 3.7;
int ii = (int) dd; // double explizit zu int konvertieren!
Console.WriteLine(ii); // 3, Nachkommastellen werden abgeschnitten

Oft wundert man sich – warum ist nach der Konvertierung die Nachkommastelle weg? Ganz einfach: Der Typ int kann keine Nachkommastellen speichern (alles nach dem Punkt ist für immer weg).

Mehr zur Konvertierung von double zu int und zum Operator (int) gibt's in der nächsten Vorlesung.

7. Formatierte Ausgabe: double schön ausgeben

Oft wird double standardmäßig mit vielen unnötigen Nullen ausgegeben. Man kann das Format anpassen:

double temp = 23.56789;
Console.WriteLine(temp); // 23.56789

Console.WriteLine(temp.ToString("F2")); // 23.57 (2 Nachkommastellen)
Console.WriteLine($"{temp:F1}");        // 23.6 (String-Interpolation)