Freitag, 14. Dezember 2012

Die if-Anweisung

Hallo zusammen,

heute widmen wir uns einem ebenfalls sehr wichtigem Thema (wie alle Grundlagen): der if-Anweisung.

Auch hier wieder ein Anfangszenario: Wir wollen einen Getränkeautomaten programmieren, der, je nach Benutzereingabe, zwei verschiedene Getränke geben kann (natürlich bauen wir keinen echten Getränkeautomaten). Der Benutzer erhält anfangs eine Konsolenausgabe, die ihm zwei Optionen gibt: Ein W für Wasser und ein T für Tee. Der Benutzer kann eines dieser Getränke mit Hilfe der Tastatur auswählen können. Falls er keines der beiden ausgewählt hat soll eine Ausgabe erfolgen, in der darauf hingewiesen wird. Andernfalls soll er den Preis erfahren, mit A Abbrechen können und mit Z Zahlen können. Falls er zahlt, bekommt er sein Getränk.

Um dieses Projekt zu realisieren ist es sinnvoll, erste einen sog. Algorithmus zu schreiben. Ein Algorithmus ist die Vorstufe zum Programmcode und soll helfen, das, was man vom Computer will, in diesen umzusetzen. Häufig werden Algorithmen bei komplizierten Programmen eingesetzt, es ist aber durchaus sinnvoll schon früher zu erlernen, wie man einen solchen schreibt. Es folgt der Algorithmus, der sich selbst erklärt:

Der Benutzer wird per Konsolenausgabe vor die Wahl zwischen Tee und Wasser gestellt. Durch Tastendruck wählt er das Getränk aus (W = Wasser, T = Tee)
       Wenn der Benutzer W drückt, dann

             Sag ihm den Preis und gib ihm die Möglichkeit mit Z zu                   zahlen, mit A abzubrechen
                    Wenn der Benutzer Z drückt, dann
                          starte Zahlvorgang und gib Getränk aus
                    Andernfalls
                          breche ab
       Wenn der Benutzer T drückt, dann
             Sag ihm den Preis und gib ihm die Möglichkeit mit Z zu                   zahlen, mit A abzubrechen
                    Wenn der Benutzer Z drückt, dann
                          starte Zahlvorgang und gib Getränk aus
                    Andernfalls
                          breche ab
       Wenn der Benutzer keiner der Tasten drückt, dann
             Gib Fehlermeldung aus
Konsole offen halten, um dem Benutzer Zeit zu geben, zu lesen

 
Jetzt müssen wir das Ganze noch in C#-Code umwandeln. Doch dazu brauchen wir eine neue Anweisung, denn wie sollen wir denn die "Wenn der Benutzer das und das macht"-Abfragen verwirklichen?

Dazu brauchen wir die nützliche if-Anweisung, bei der der boolesche Datentyp "bool" eine große Rolle spielt, der im letzten Post näher beschrieben wird.

Doch schreiben wir erste einmal den Anfang des Programms, den wir auch schon schreiben können:

//Benutzerinformation
Console.WriteLine("Herzlich Willkommen bei Ihrem Getränkautomaten!\nSie haben die Wahl zwischen Tee und Wasser.\nUm Tee zu erhalten, drücken Sie bitte \"T\" auf der Tastatur,\num Wasser zu erhalten, drücken Sie bitte \"W\".\nWir warten . . .");
//  .   noch
//  .   nicht
//  .   geschrieben
//Und am Ende, damit die Konsole sich nicht sofort schließt
Console.ReadKey();

Doch nun zu if:
Um eine if-Abfrage zu realisieren, schreiben wir erst einmal das C#-Schlüsselwort if, was dunkelblau dargestellt wird. Danach folgt eine sich öffnende Klammer, der boolesche Ausdruck, dann eine Klammer zu.
In die Zeile darunter wird eine geschweifte Klammer auf ({) und in der nächsten Zeile darunter ein geschweifte Klammer zu (}) geschrieben. Zwischen diese Klammern kommen die C#-Anweisungen, die ausgeführt werden sollen, wenn der boolesche Ausdruck true ergibt. Das Gerüst:

if(boolescher Ausdruck)
{
       Anweisungen, die ausgeführt werden wenn der boolesche Ausdruck true ergibt
}

In die Klammern muss jetzt ein boolescher Ausdruck. Wir vergleichen hier die Benutzereingabe, die zuvor mit Console.ReadLine() und in einem string gespeichert wird, mit dem String "W" für Wasser. Damit der Benutzer auch ein kleines w eingeben kann, wenden wir auf Console.ReadLine() die String-Methode ToUpper() an, die alles zu Großbuchstaben macht:

string benutzereingabe = Console.ReadLine().ToUpper();
if (benutzereingabe == "W")
{
}

Den Inhalt der Klammern schreiben wir nachher, wir machen jetzt erste einmal mit dem nächsten Fall weiter.
Wenn der Benutzer nicht W gedrückt hat, soll überprüft werden, ob er vielleicht T gedrückt hat. Um dem Computer zu zeigen, dass zwei Überprüfungen aneinanderhängen, gibt es die else-if-Anweisung. Sie funktioniert wie if, aber dem if ist noch ein else angehängt, wodurch der Computer die beiden if-Abfragen als zusammenhängend betrachtet.

else if (benutzereingabe == "T")
{
}

Nun ist auch der Fall behandelt, wenn der Benutzer T drückt. Doch wie bekommen wir es hin, dass in allen anderen Fällen eine Fehlermeldung ausgegeben wird? Müssen wir dafür alle Möglichkeiten überprüfen, die der Benutzer bei der Eingabe hat? Zum Glück gibt es in C# die else-Anweisung. Falls nach mind. einer if-Anweisung nicht die bisher überprüften Fälle eingetreten sind, tritt else ein. Jetzt macht auch else-if mehr Sinn. Natürlich ist es keine Pflicht, nach jedem if-Block else zu schreiben, aber bei uns bietet sich das an. Beim else-Block gibt es keine booleschen Ausdrücke in Klammern mehr:

else
{
}
Im else-Teil können wir gleich die Fehlermeldung ausgeben, also:

else
{
       Console.WriteLine("Ihre Eingabe (" + benutzereingabe + ") konnte leider keinem Getränk zugeordnet werden!\nBitte starten Sie das Programm erneut.");
}

Unser Code bisher:

namespace Getränkeautomat
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Herzlich Willkommen bei Ihrem Getränkautomaten!\nSie haben die Wahl zwischen Tee und Wasser.\nUm Tee zu erhalten, drücken Sie bitte \"T\" auf der Tastatur,\num Wasser zu erhalten, drücken Sie bitte \"W\".\nWir warten . . .");
            //Die Benutzereingabe wird in Großbuchstaben umgewandelt und in der string-Variablen "benutzereingabe" gespeichert
            string benutzereingabe = Console.ReadLine().ToUpper();

            //falls der Benutzer ein "W" eingegeben hat...
            if (benutzereingabe == "W")
            {
                //...mach das hier
            }

            //falls der Benutzer kein "W" eingegeben hat wird hierher gesprungen, wo überprüft wird,
            //ob der Benutzer ein T eingegeben hat. Falls das true ergibt...
            else if (benutzereingabe == "T")
            {
                //...wird das hier abgearbeitet
            }
            //falls die beiden oberen Fälle false ergeben, wird hierher gesprungen. Da wir im else-Teil
            //für alle anderen Fälle sorgen, ist hier keine Klammer mit booleschem Ausdruck notwendig.
            //Hier wird auch der Sinn von else-if klar, denn wenn man zweimal nur if schreiben würde, würde hier
            //auch bei Eingabe von "W" ein Fehlermeldung ausgegeben werden.
            else
            {
                Console.WriteLine("Ihre Eingabe (" + benutzereingabe + ") konnte leider keinem Getränk zugeordnet werden!\nBitte starten Sie das Programm erneut.");
            }
            Console.ReadKey();
        }
    }
}

Auch hier gibt es wieder Layoutfehler.
Jetzt müssen wir uns noch um die Auswahlmöglichkeiten innerhalb des if- und des else-if-Blocks kümmern:
Jeweils soll der Benutzer eine Meldung bekommen, die den Erfolg der Getränkeauswahl ausgibt. Dann soll er die Möglichkeit zwischen Zahlen und Abbrechen bekommen. Sollte der Benutzer einen anderen Buchstaben als A für Abbrechen oder Z für Zahlen eingeben, wird ebenfalls abgebrochen.
In C# ist es möglich, if-Anweisungen zu verschachteln. Hier ist der gesamte Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace Getränkeautomat
{
    class Program
    {

        static void Main(string[] args)
        {
            Console.WriteLine("Herzlich Willkommen bei Ihrem Getränkautomaten!\nSie haben die Wahl zwischen Tee und Wasser.\nUm Tee zu erhalten, drücken Sie bitte \"T\" auf der Tastatur,\num Wasser zu erhalten, drücken Sie bitte \"W\".\nWir warten . . .");

            //Die Benutzereingabe wird in Großbuchstaben umgewandelt und in der string-Variablen "benutzereingabe" gespeichert
            string benutzereingabe = Console.ReadLine().ToUpper();

            //falls der Benutzer ein "W" eingegeben hat...
            if (benutzereingabe == "W")
            {
                //...mach das hier
                Console.WriteLine("Wenn Sie zahlen wollen, geben Sie bitte ein Z ein:");
                string benutzereingabe2 = Console.ReadLine().ToUpper();
                if (benutzereingabe2 == "Z")
                {
                    Console.WriteLine("Der Zahlvorgang wurde gestartet...");
                    Thread.Sleep(1000);
                    Console.WriteLine("Sie haben erfolgreich gezahlt!");
                }
                else
                {
                    Console.WriteLine("Abbrechen...");
                }
            }

            //falls der Benutzer kein "W" eingegeben hat wird hierher gesprungen, wo überprüft wird,
            //ob der Benutzer ein T eingegeben hat. Falls das true ergibt...
            else if (benutzereingabe == "T")
            {
                //...wird das hier abgearbeitet
                Console.WriteLine("Wenn Sie zahlen wollen, geben Sie bitte ein Z ein:");
                string benutzereingabe2 = Console.ReadLine().ToUpper();
                if (benutzereingabe2 == "Z")
                {
                    Console.WriteLine("Der Zahlvorgang wurde gestartet...");
                    Thread.Sleep(1000);
                    Console.WriteLine("Sie haben erfolgreich gezahlt!");
                }
                else
                {
                    Console.WriteLine("Abbrechen...");
                }
            }

            //falls die beiden oberen Fälle false ergeben, wird hierher gesprungen. Da wir im else-Teil
            //für alle anderen Fälle sorgen, ist hier keine Klammer mit booleschem Ausdruck notwendig.
            //Hier wird auch der Sinn von else-if klar, denn wenn man zweimal nur if schreiben würde, würde hier
            //auch bei Eingabe von "W" ein Fehlermeldung ausgegeben werden.
            else
            {
                Console.WriteLine("Ihre Eingabe (" + benutzereingabe + ") konnte leider keinem Getränk zugeordnet werden!\nBitte starten Sie das Programm erneut.");
            }
            Console.ReadKey();
        }
    }
}

Auch hier ist eine neue Anweisung dabei: Thread.Sleep(1000); Diese Anweisung hält das Programm (Thread) für 1000 Millisekunden an. Damit diese Anweisung überhaupt verfügbar ist, muss in den using-Statements "using System.Threading;" hinzugefügt werden, wodurch der Compiler alle "Vokabeln" lernt, die im Namespace "System.Threading" verfügbar sind. Wenn man das weglassen würde, müsste man jedes Mal "System.Threading.Thread.Sleep(1000);" geschrieben werden. Wir werden später, bei der Objektorientierung, noch einmal auf Namespaces eingehen.

Nun sind wir auch in der Lage, unseren Taschenrechner fertig zu programmieren. Der gesamte Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Taschenrechner
{
    class Program
    {
        static void Main(string[] args)
        {
            double ergebnis;
            Console.WriteLine("Geben Sie die erste Zahl ein:");
            double zahl1 = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("Bitte geben Sie nun die zweite Zahl ein:");
            double zahl2 = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("Bitte geben Sie nun die Operation ein:");
            string operation = Console.ReadLine();
            if (operation == "+")
            {
                ergebnis = zahl1 + zahl2;
                Console.WriteLine("Ergebnis: " + ergebnis.ToString());
            }
            else if (operation == "-")
            {
                ergebnis = zahl1 - zahl2;
                Console.WriteLine("Ergebnis: " + ergebnis.ToString());
            }
            else if (operation == "/" || operation == ":")
            {
                ergebnis = zahl1 / zahl2;
                Console.WriteLine("Ergebnis: " + ergebnis.ToString());
            }
            else if (operation == "*" || operation == "x" || operation == "X")
            {
                ergebnis = zahl1 * zahl2;
                Console.WriteLine("Ergebnis: " + ergebnis.ToString());
            }
            else
            {
                Console.WriteLine("Ungültige Eingabe!");
            }
            Console.ReadKey();
        }
    }
}

Auch hier ist wieder etwas unbekanntes dabei: In bestimmten if-Anweisungen steht ein doppeltes | (AltGr + <). Das bedeutet in C# ein "Oder", d.h., wenn eine der beiden booleschen Ausdrücke "true" ergibt, werden die Anweisungen ausgeführt. Das ist hier sinnvoll, da es auch Benutzer gibt, die statt "/" ":" eingeben. Auch ein "Und" kann man programmieren: "&&". Hierbei müssen alle Bestimmungen zutreffen, damit die folgenden Anweisungen ausgeführt werden. Natürlich kann man auch mehrere "Und"s oder "Oder"s hintereinander hängen.

Um hier auch korrekte Ergebnisse bei der Division zu gewährleisten werden doubles verwendet, da sonst z.B. bei der Operation 1/3 bei Verwendung eines int 0 statt 0,333333333... ausgegeben wird, da gerundet wird. Dementsprechend muss auch die Anweisung "Convert.ToInt32" in "Convert.ToDouble" geändert werden. Allerdings gilt für den Benutzer die Einschränkung für Programmierer nicht, sodass dieser ein deutsches Komma auch wirklich als Trennzeichen zwischen Ganzzahl und Nachkommastellen verwenden kann. Das ist aber von der Spracheinstellung des Systems abhängig.

Der Rest des Programmcodes erklärt sich selbst.

Bis zum nächsten mal,
Julian

Samstag, 1. Dezember 2012

Primitive Datentypen - Variablen - Part 2

Hallo zusammen und herzlich willkommen bei der Fortsetzung zum Thema Variablen und primitive Datentypen!

Letztes Mal sind wir soweit gekommen, dass wir eine int-Variable mit 2 addiert haben und die Ergebnisse vor und nach der Addition ausgegeben haben.

In diesem Post schauen wir uns auch die anderen primitiven Datentypen genauer an, denn bei fast jedem Datentyp gibt es eine Besonderheit, die es zu beachten gilt.

Bis jetzt haben wir erst den Datentyp int genauer angeschaut. Doch wie sieht es z. B. bei dem ebenfalls häufig genutzten Datentyp double aus?
Wie aus der Tabelle des vorletzten Posts zu entnehmen ist, kann dieser sog. Gleitkommazahlen speichern, d. h. er speichert Zahlen mit einer bestimmten Anzahl an Dezimalstellen. Doch wenn wir einen double erstellen und diesen mit der uns in Deutschland üblichen Schreibweise initialisieren, also z. B. 3,234, werden wir uns über die Rechenergebnisse wundern, denn im englischen entspricht ein Komma einem Punkt und umgekehrt. Um also einer Variablen vom Typ double einen Wert zuzuweisen, müssen wir statt "2,234" "2.234" schreiben, also

double d = 2.234;
Wenn wir allerdings versuchen, einem float oder einem decimal, die ja auch Gleitkommazahlen speichern, den Wert auf die gleiche Schreibweise zuzuweisen, führt das aber zu einem Fehler:
Literale vom Typ "Double" können nicht implizit in den Typ "float" konvertiert werden. Verwenden Sie ein F-Suffix, um ein Literal mit diesem Typ zu erstellen.
Dieser Fehler tritt deswegen auf, da eine Gleitkommazahl in C# implizit (automatisch) ein double ist. Da der Computer aber nicht einfach so einen double in einen float oder decimal umwandeln kann, muss das mit unserer Hilfe geschehen. Das geht auf die verschiedensten Arten, die gängigste ist aber, einem float-Zuweisungswert ein f/F und einem decimal-Zuweisungswert ein m/M anzuhängen, also z. B.
float f = 2.234f;

Als nächstes wollen wir uns den Datentyp bool anschauen. Auf den ersten Blick kann man ihn fast nicht gebrauchen, da er nur 2 Werte, nämlich true und false speichern kann. Doch der erste Blick täuscht, denn dieser Datentyp wird im nächsten Post noch sehr wichtig werden, denn mit ihm kann man Bedingungen überprüfen.
Einem bool einem Wert zuzuweisen funktioniert nicht anders als bei anderen Datentypen:

bool b = true;

Auch ihm können wir Ausdrücke zuweisen, die allerdings etwas anders funktionieren, als beispielsweise bei einem int. Bei einem int können wir beispielsweise folgendes schreiben:

int i = 5 - 2;

Der int beinhaltet jetzt den Wert 3. Um einem bool mit einem sog. booleschen Ausdruck einen Wert zuzuweisen, müssen die Ausdrücke immer eine Bedingung aufstellen. Wenn diese Bedingung sich als falsch erweist, bekommt der bool den Wert false andernfalls true. Ein Beispiel. Wir nehmen zweimal einen int, weisen ihnen Werte zu und vergleichen die Werte:

int i = 5 - 2;
int j = 5 + 8;
bool b = i > j;

Wir haben zweimal einen int mit den Werten 3 und 13. Im booleschen Ausdruck wird überprüft, ob i größer ist als j. Da dies falsch ist, bekommt der boolesche Datentyp b den Wert falsch zugewiesen, was man auch mit einer Konsolenausgabe überprüfen kann:

Console.WriteLine(b);

Das "Ist-Kleiner-Als"-Zeichen (<) würde true ergeben. Dann gibt es noch die Möglichkeiten auf Kleiner-Gleich (<=), Größer-Gleich (>=), Ist-Ungleich (!=) und Ist-Gleich (==). Besonders beim Ist-Gleich ist darauf zu achten, dass man zweimal ein Gleichheitszeichen schreibt, da ein einfaches Gleichheitszeichen den Zuweisungsoperator und nicht den Vergleichsoperator darstellt! Man kann hiermit fast alles vergleichen, also auch string und andere Klassen.

Beim Datentyp string gibt es auch ein paar Regeln:
Der Text, mit dem man eine string-Variable initialisiert, wird in Anführungsstrichen angegeben und darf nicht einfach so geschrieben werden:

string s = "Hallo";

Was macht man aber, wenn man in der Zeichenkette ein Anführungszeichen enthalten haben will? Dazu gibt es die Escape-Sequenzen. Wenn wir ein Anführungszeichen haben will, ohne dass der string damit beendet wäre, schreiben wir einfach \" (Backslash und kein Slash!), um einen Zeilenumbruch zu erzeugen, schreiben wir in Windows \n (für New Line), um einen Backslash in der Zeichenkette zu haben, ist ein doppelter Backslash nötig (\\). Eine Liste der Escape-Sequenzen:

Escapesequenz
Beschreibung
\’xe »_
Einfaches Anführungszeichen
\\"
Doppeltes Anführungszeichen
\\
Umgekehrter Schrägstrich (Backslash)
\0
Null
\a
Alert (Warnung)
\b
Rückschritt
\f
Vorschub
\n
Neue Zeile
\r
Wagenrücklaufzeichen
\t
Tabulator
\v
Vertikaler Tabulator
\xdddd
Zeichen dddd, wobei d für eine Hexadezimalstelle steht

Was passiert, wenn ich einen string mit einem anderen addiere? Die Zeichenfolgen werden aneinander gehängt, auch wenn sie Zahlen enthalten.

string s = "Hallo";
string t = "Welt";
string vollständig = s + " " + t;
Console.WriteLine(vollständig);

Hier wird "Hallo Welt" ausgegeben. Das Leerzeichen, welches nach s eingefügt wird ist notwendig, um nicht die Ausgabe "HalloWelt" zu erzielen. Alternativ zur oben gezeigten Variante können wir auch den string in der WriteLine-Mehtode zusammenfügen, also:

Console.WriteLine(s + " " + t);

Es ist außerdem möglich, in der Console.WriteLine()- und in der Console.Write()-Methode Platzhalter für Variablen zu erschaffen:

Console.WriteLine("{0} {1}", s, t);
Die erste Variable nach dem Komma, die auch jeder andere Typ sein kann, also z. B. ein int oder float (sie werden automatisch von der Methode WriteLine() in ein string umgewandelt), bekommt den Platzhalter 0 zugewiesen, der 2. Platzhalter (also {1}) bekommt die zweite Variable zugewiesen, usw. Die Platzhalter müssen natürlich nicht nach der Reihenfolge angeordnet sein, also ist auch folgendes möglich:

Console.WriteLine("{1} {0}", s, t);
Hier wird allerdings die Reihenfolge vertauscht, die Ausgabe ist "Welt Hallo". 
Auch zweimal der gleich Platzhalter ist erlaubt:
Console.WriteLine("{0} {0}", s, t);
Hier wird "Hallo Hallo" ausgegeben.
Im nächsten Schritt programmieren wir einen kleinen Konsolen-Taschenrechner, der nur die Addition beherrscht. Der Programmcode ist mit Kommentaren versehen und erklärt sich daher selbst:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Taschenrechner
{
    class Program
    {
        static void Main(string[] args)
        {
            //Deklaration von der int-Variablen "zahl1"
            int zahl1;
            //Konsolenausgabe mit dem Text "Bitte geben Sie die erste Zahl ein" und nachfolgendem Zeilenumbruch
            Console.WriteLine("Bitte geben Sie die erste Zahl ein:");
            /********************************************************************************************************************************
             * Initialisierung der Variablen zahl1 mit dem vom Benutzer eingegebenem Wert.
             * Da die Methoden "ReadLine" und "Read" einen String liefern, muss dieser umgewandelt werden.
             * Das geschieht über die statische Klasse (auch Console ist eine solche) Convert
             * In dieser Klasse gibt es verschiedene Methoden, mit Hilfe derer man verschiedene primitive Datentypen in andere umwandeln kann
             * Wir nutzen hier die Methode "ToInt32", da wir den Text in einen int verwandeln müssen
             ********************************************************************************************************************************/
            zahl1 = Convert.ToInt32(Console.ReadLine());
            //Konsolenausgabe wie oben
            Console.WriteLine("Bitte geben Sie nun die zweite Zahl ein:");
            //Deklaration und Initialisierung von zahl2
            int zahl2 = Convert.ToInt32(Console.ReadLine());
            //Ausgabe des Ergebnisses. Es gelten die mathematischen Regeln. Damit hier nicht einfach nur zahl1 und zahl2 in strings umgewandelt werden
            //und dann ausgegeben werden und so bei einer Eingabe von 1 + 1 als Ergebnis 11 herauskommt, muss um diese Rechnung eine Klammer gesetzt werden,
            //damit erst das Ergebnis als int ausgerechnet wird und dann in einen string umgewandelt und ausgegeben wird
            Console.WriteLine("Ergebnis: " + (zahl1 + zahl2));
            //Alternativ dazu könnte man auch, wie folgt, eine neue Variable "ergebnis" deklarieren und ihr den Term zahl1 + zahl2 zuweisen
            //und diese Variable dann ausgeben:
            int ergebnis = zahl2 + zahl1; //Die Reihenfolge spielt hier wegen des Distributivgesetzes keine Rolle
            Console.WriteLine("Ergebnis: " + ergebnis); 
            //Und damit sich die Konsole nicht gleich wieder schließt...
            Console.ReadKey();
        }
    }
}
Da hier einige Kommentarzeilen zu lang waren, wurden sie in zwei Zeilen aufgeteilt, wodurch hier Fehler entstanden.
Wenn man hier eine Zahl eingibt, die größer als der Wertebereich eines int ist, wird eine sog. Exception geworfen. Da das Thema Exceptionbehandlung erst später durchgenommen wird, muss man sich mit dem Wertebereich begnügen oder einen anderen Datentyp wählen, was aber auch andere Codeänderungen nach sich trägt.
Dieser Taschenrechner ist sicherlich nicht der beste, aber immerhin kann er Addieren. Für diesen Post sind wir fertig mit dem Projekt. Herzlichen Glückwunsch.
Im nächsten Post geht es um die if-Anweisung, mit deren Hilfe wir auch die anderen Grundrechenarten in den Taschenrechner einbauen können.
Bis dahin,
Julian