Verwenden von ganzen und Gleitkommazahlen in C#

Artikel
05/10/2023

In diesem Tutorial werden die numerischen Typen in C# erläutert. Sie schreiben einen Teil des Codes, kompilieren diesen und führen ihn aus. Das Tutorial enthält eine Reihe von Lektionen, in denen Zahlen und mathematische Vorgänge in C# untersucht werden. In diesen Lektionen lernen Sie die Grundlagen der Programmiersprache C# kennen.

Tipp

Verwenden Sie die Tastenkombination (STRG + v oder BEFEHL + v), um einen Codeschnipsel im Fokusmodus einzufügen.

Voraussetzungen

Für dieses Tutorial wird vorausgesetzt, dass Sie einen Computer für die lokale Entwicklung eingerichtet haben. Installationsanweisungen und eine Übersicht über die Anwendungsentwicklung in .NET finden Sie unter Einrichten Ihrer lokalen Umgebung.

Wenn Sie keine lokale Umgebung einrichten möchten, wechseln Sie zur interaktiven browserinternen Version dieses Tutorials.

Erkunden von arithmetischen Operationen mit ganzen Zahlen

Erstellen Sie ein Verzeichnis mit dem Namen numbers-quickstart. Legen Sie es als das aktuelle Verzeichnis fest, und führen Sie den folgenden Befehl aus:

dotnet new console -n NumbersInCSharp -o .

Wichtig

Die C#-Vorlagen für .NET 6 verwenden Anweisungen der obersten Ebene. Ihre Anwendung passt möglicherweise nicht zum Code in diesem Artikel, wenn Sie bereits ein Upgrade auf .NET 6 durchgeführt haben. Weitere Informationen finden Sie im Artikel Neue C#-Vorlagen generieren Anweisungen auf oberster Ebene.

Das .NET 6 SDK fügt auch eine Reihe impliziterglobal using-Anweisungen für Projekte hinzu, die die folgenden SDKs verwenden:

Microsoft.NET.Sdk
Microsoft.NET.Sdk.Web
Microsoft.NET.Sdk.Worker

Diese impliziten global using-Anweisungen enthalten die gängigsten Namespaces für den Projekttyp.

Weitere Informationen finden Sie im Artikel zum Thema „Implizite Verwendung von Anweisungen“

Öffnen Sie Program.cs in Ihrem bevorzugten Editor, und ersetzen Sie den Inhalt der Datei durch folgenden Code:

int a = 18;
int b = 6;
int c = a + b;
Console.WriteLine(c);

Führen Sie diesen Code aus, indem Sie dotnet run in Ihr Befehlsfenster eingeben.

Sie haben eine der grundlegenden arithmetischen Operationen mit ganzen Zahlen kennengelernt. Der int-Typ steht für integer, d. h. eine Null oder eine positive oder negative ganze Zahl. Sie verwenden zum Addieren das +-Symbol. Zu den anderen häufig verwendeten arithmetischen Operationen für ganze Zahlen zählen Folgende:

- zur Subtraktion
* zur Multiplikation
/ zur Division

Erkunden Sie zunächst die anderen Operationen. Fügen Sie diese Zeilen nach der Zeile hinzu, die den Wert von c schreibt:

// subtraction
c = a - b;
Console.WriteLine(c);

// multiplication
c = a * b;
Console.WriteLine(c);

// division
c = a / b;
Console.WriteLine(c);

Führen Sie diesen Code aus, indem Sie dotnet run in Ihr Befehlsfenster eingeben.

Wenn Sie möchten, können Sie auch experimentieren, indem Sie mehrere arithmetische Operationen in dieselbe Zeile schreiben. Testen Sie zum Beispiel c = a + b - 12 * 17;. Das Kombinieren von Variablen und konstanten Zahlen ist erlaubt.

Tipp

Bei Ihren ersten Schritten mit C# (oder einer anderen Programmiersprache) kann es zu Fehlern kommen, wenn Sie Codes schreiben. Der Compiler findet diese Fehler und meldet diese. Sollte die Ausgabe Fehlermeldungen enthalten, sehen Sie sich den Beispielcode und den Code in Ihrem Fenster an, um festzustellen, was behoben werden muss. Durch diese Übung lernen Sie die Struktur eines C#-Codes kennen.

Sie haben den ersten Schritt abgeschlossen. Bevor Sie mit dem nächsten Abschnitt beginnen, verschieben wir den aktuellen Code in eine separate Methode. Eine Methode ist eine Reihe von Anweisungen, die gruppiert werden und einen Namen erhalten. Sie rufen eine Methode auf, indem Sie den Namen der Methode gefolgt von () schreiben. Wenn Sie Ihren Code in Methoden organisieren, ist der Einstieg in die Arbeit mit einem neuen Beispiel einfacher. Anschließend sollte der Code wie folgt aussehen:

WorkWithIntegers();

void WorkWithIntegers()
{
    int a = 18;
    int b = 6;
    int c = a + b;
    Console.WriteLine(c);


    // subtraction
    c = a - b;
    Console.WriteLine(c);

    // multiplication
    c = a * b;
    Console.WriteLine(c);

    // division
    c = a / b;
    Console.WriteLine(c);
}

Die Zeile WorkWithIntegers(); ruft die Methode auf. Im folgenden Code wird die Methode deklariert und definiert.

Erkunden der Reihenfolge der Operationen

Kommentieren Sie den Aufruf von WorkingWithIntegers() aus. Dadurch wird die Ausgabe weniger überladen, wenn Sie in diesem Abschnitt arbeiten:

//WorkWithIntegers();

Mit // wird ein Kommentar in C# begonnen. Kommentare sind Texte, die Sie in Ihrem Quellcode beibehalten, jedoch nicht als Code ausführen möchten. Der Compiler generiert keinen ausführbaren Code über die Kommentare. Da WorkWithIntegers() eine Methode ist, müssen Sie nur eine Zeile auskommentieren.

Die Programmiersprache C# definiert anhand von Regeln, die Sie aus der Mathematik kennen, die Rangfolge verschiedener arithmetischer Operationen. Multiplikation und Division haben gegenüber der Addition und Subtraktion Vorrang. Überprüfen Sie dies, indem Sie nach dem Aufruf von WorkWithIntegers() den folgenden Code hinzufügen und dotnet run ausführen:

int a = 5;
int b = 4;
int c = 2;
int d = a + b * c;
Console.WriteLine(d);

Die Ausgabe zeigt, dass vor der Addition die Multiplikation ausgeführt wurde.

Sie können eine andere Operationsreihenfolge erzwingen, indem Sie die Operation bzw. die Operationen, die zuerst ausgeführt werden soll bzw. sollen, mit Klammern umschließen. Fügen Sie die folgenden Zeilen hinzu, und führen Sie sie aus:

d = (a + b) * c;
Console.WriteLine(d);

Machen Sie sich damit vertraut, indem Sie viele verschiedene Operationen kombinieren. Fügen Sie in etwa die folgenden Zeilen hinzu. Testen Sie erneut dotnet run.

d = (a + b) - 6 * c + (12 * 4) / 3 + 12;
Console.WriteLine(d);

Vielleicht haben Sie bereits ein interessantes Verhalten bei den ganzen Zahlen bemerkt. Bei der Division ganzer Zahlen kommt immer ein ganzzahliges Ergebnis heraus, selbst wenn Sie als Ergebnis einen Dezimal- oder Bruchteil erwarten würden.

Wenn Sie dieses Verhalten noch nicht beobachtet haben, testen Sie den folgenden Code:

int e = 7;
int f = 4;
int g = 3;
int h = (e + f) / g;
Console.WriteLine(h);

Geben Sie erneut dotnet run ein, um die Ergebnisse anzuzeigen.

Bevor Sie fortfahren, kopieren Sie den gesamten Code, den Sie in diesem Abschnitt geschrieben haben, und fügen ihn in eine neue Methode ein. Rufen Sie die neue Methode OrderPrecedence auf. Ihr Code sollte in etwa wie folgt aussehen:

// WorkWithIntegers();
OrderPrecedence();

void WorkWithIntegers()
{
    int a = 18;
    int b = 6;
    int c = a + b;
    Console.WriteLine(c);


    // subtraction
    c = a - b;
    Console.WriteLine(c);

    // multiplication
    c = a * b;
    Console.WriteLine(c);

    // division
    c = a / b;
    Console.WriteLine(c);
}

void OrderPrecedence()
{
    int a = 5;
    int b = 4;
    int c = 2;
    int d = a + b * c;
    Console.WriteLine(d);

    d = (a + b) * c;
    Console.WriteLine(d);

    d = (a + b) - 6 * c + (12 * 4) / 3 + 12;
    Console.WriteLine(d);

    int e = 7;
    int f = 4;
    int g = 3;
    int h = (e + f) / g;
    Console.WriteLine(h);
}

Erkunden der Genauigkeit und Grenzwerte ganzer Zahlen

Im vorherigen Beispiel haben Sie gesehen, dass das Ergebnis bei der Division ganzer Zahlen abgeschnitten wird. Sie erhalten den Restwert remainder mithilfe des Modulo-Operators, dem %-Zeichen. Versuchen Sie es nach dem Methodenaufruf von OrderPrecedence() mit folgendem Code:

int a = 7;
int b = 4;
int c = 3;
int d = (a + b) / c;
int e = (a + b) % c;
Console.WriteLine($"quotient: {d}");
Console.WriteLine($"remainder: {e}");

Der integer-C#-Typ unterscheidet sich noch in einem weiteren Punkt von einer mathematischen ganzen Zahl: Der int-Typ ist mit minimalen und maximalen Grenzwerten versehen. Fügen Sie diesen Code hinzu, um die jeweiligen Grenzwerte zu sehen:

int max = int.MaxValue;
int min = int.MinValue;
Console.WriteLine($"The range of integers is {min} to {max}");

Wenn bei einer Berechnung ein Wert herauskommt, der diese Grenzwerte überschreitet, liegt eine Unterlauf- oder Überlaufbedingung vor. Die Antwort gibt dann den Bereich der Grenzwerte an. Fügen Sie die folgenden zwei Zeilen hinzu, um ein Beispiel anzuzeigen:

int what = max + 3;
Console.WriteLine($"An example of overflow: {what}");

Beachten Sie, dass die Antwort sehr nah an der minimalen (negativen) ganzen Zahl liegt. Sie entspricht min + 2. Die Additionsoperation hat die zulässigen Werte für ganze Zahlen überlaufen. Die Antwort enthält eine sehr große negative Zahl, da ein Überlauf den größtmöglichen ganzzahligen Wert bis zum kleinstmöglichen Wert umschließt.

Wenn der int-Typ nicht Ihren Anforderungen entspricht, so gibt es verschiedene numerische Typen mit anderen Grenzwerten und Genauigkeitsgraden, die Sie verwenden können. Werfen wir im Folgenden einmal einen Blick auf diese anderen Typen. Bevor Sie mit dem nächsten Abschnitt beginnen, verschieben Sie den in diesem Abschnitt geschriebenen Code in eine separate Methode. Nennen Sie es TestLimits.

Arbeiten mit dem Double-Typ

Der numerische Typ double stellt eine Gleitkommazahl mit doppelter Genauigkeit dar. Falls Ihnen diese Benennungen nichts sagen, beachten Sie die folgenden Erläuterungen: Eine Gleitkommazahl wird verwendet, um sehr große oder sehr kleine Zahlen, die keine ganzen Zahlen sind, darzustellen. Doppelte Genauigkeit ist ein relativer Begriff, der die Anzahl der binären Ziffern beschreibt, die zum Speichern des Werts verwendet werden. Zahlen mit doppelter Genauigkeit besitzen die doppelte Anzahl von binären Ziffern wie Zahlen mit einfacher Genauigkeit. Auf Bei modernen Computern werden häufiger Zahlen mit doppelter Genauigkeit verwendet statt mit einfacher Genauigkeit. Zahlen mit einfacher Genauigkeit werden mit dem Schlüsselwort float deklariert. Sehen wir uns dies einmal genauer an. Fügen Sie den folgenden Code hinzu, und zeigen Sie das Ergebnis an:

double a = 5;
double b = 4;
double c = 2;
double d = (a + b) / c;
Console.WriteLine(d);

Beachten Sie, dass die Antwort die Dezimalzahl des Quotienten enthält. Testen Sie einen etwas komplizierteren Ausdruck mit Werten vom Typ „double“:

double e = 19;
double f = 23;
double g = 8;
double h = (e + f) / g;
Console.WriteLine(h);

Der Bereich eines Werts vom Typ „double“ ist weitaus größer als bei ganzzahligen Werten. Fügen Sie den folgenden Code unter dem Code hinzu, den Sie bereits geschrieben haben:

double max = double.MaxValue;
double min = double.MinValue;
Console.WriteLine($"The range of double is {min} to {max}");

Diese Werte werden in der wissenschaftlichen Schreibweise ausgegeben. Die Zahl links von E ist die Mantisse. Die Zahl rechts ist der Exponent als Potenz von 10. Wie bei Dezimalzahlen in der Mathematik können double-Werte in C# Rundungsfehler aufweisen. Testen Sie den folgenden Code:

double third = 1.0 / 3.0;
Console.WriteLine(third);

Sie wissen, dass 0.3 als endliche Anzahl von Malen nicht genau dasselbe ist wie 1/3.

Übung

Testen Sie für den double-Typ andere Berechnungen mit großen und kleinen Zahlen sowie mit Multiplikation und Division. Testen Sie kompliziertere Berechnungen. Nachdem Sie sich nun einige Zeit lang mit der Übung auseinander gesetzt haben, kopieren Sie den von Ihnen geschriebenen Code, und fügen Sie ihn in eine neue Methode ein. Vergeben Sie einen Namen für die neue Methode WorkWithDoubles.

Arbeiten mit Dezimaltypen

Sie haben die grundlegenden numerischen Typen in C# – „integer“ und „double“ – kennengelernt. Es gibt einen weiteren Typ, den Sie kennen sollten: den decimal-Typ. Der decimal-Typ weist einen kleineren Bereich als double auf, aber eine höhere Genauigkeit. Sehen wir uns das einmal genauer an:

decimal min = decimal.MinValue;
decimal max = decimal.MaxValue;
Console.WriteLine($"The range of the decimal type is {min} to {max}");

Beachten Sie, dass der Bereich kleiner ist als beim double-Typ. Sie können sehen, dass die Genauigkeit beim Typ „decimal“ höher ist, wenn Sie den folgenden Code testen:

double a = 1.0;
double b = 3.0;
Console.WriteLine(a / b);

decimal c = 1.0M;
decimal d = 3.0M;
Console.WriteLine(c / d);

Mit dem Suffix M neben einer Zahl geben Sie an, dass eine Konstante den decimal-Typ verwenden soll. Andernfalls nimmt der Compiler den Typ double an.

Hinweis

Der Buchstabe M wurde als visuell eindeutigster Buchstabe zur Unterscheidung zwischen den Schlüsselwörtern double und decimal ausgewählt.

Beachten Sie, dass der aus dieser arithmetischen Operation resultierende Wert vom Typ „decimal“ rechts neben dem Dezimalpunkt mehr Ziffern enthält.

Übung

Nachdem Sie nun die verschiedenen numerischen Typen kennengelernt haben, schreiben Sie Code, der den Flächeninhalt eines Kreises mit einem Radius von 2,5 cm berechnet. Denken Sie daran, dass der Flächeninhalt eines Kreises durch das Quadrat des Radius multipliziert mit Pi gebildet wird. Hinweis: .NET bietet eine Konstante für Pi (Math.PI), die Sie für die Berechnung dieses Werts verwenden können. Math.PI, wie alle im System.Math-Namespace deklarierten Konstanten, ist ein double-Wert. Aus diesem Grund sollten Sie double anstelle von decimal-Werten für diese Aufgabe verwenden.

Sie sollten eine Antwort zwischen 19 und 20 erhalten. Sie können Ihre Antwort anhand des fertig gestellten Beispielcodes auf GitHub prüfen.

Wenn Sie möchten, testen Sie andere Formeln.

Sie haben den Schnellstart „Zahlen in C#“ abgeschlossen. Sie können mit dem Schnellstart Branches und Schleifen in Ihrer eigenen Entwicklungsumgebung fortfahren.

Weitere Informationen zu Zahlen in C# finden Sie auch in folgenden Artikeln: