Safari Books Online is a digital library providing on-demand subscription access to thousands of learning resources.
In diesem Abschnitt wollen wir einen kleinen »Taschenrechner« programmieren, der zwei Ganzzahlen addiert, die der Anwender des Programms eingeben kann. Die beiden eingegebenen Zahlen sollen in Variablen gespeichert, dann addiert und schließlich soll das Ergebnis der Addition angezeigt werden.
Starten Sie Visual C# 2010 Express und erstellen Sie ein neues Projekt des Typs Konsolenanwendung (Befehl: Datei/Neues Projekt). Nennen Sie das Projekt Rechner1 und klicken Sie auf OK.
Geben Sie in die Main-Methode die folgenden Anweisungen ein, mit denen der Anwender aufgefordert wird, die Zahlen einzugeben, die addiert werden sollen:
static void Main()
{
Console.WriteLine("Geben Sie den ersten Operanden ein ");
Console.WriteLine("Geben Sie den zweiten Operanden ein ");
}Jetzt fehlt uns noch eine Methode der Klassenbibliothek, die wir verwenden können, um die Zahlen einzulesen, die der Anwender des Programms über die Tastatur eingibt. Fügen Sie nach der ersten WriteLine-Anweisung eine Leerzeile ein. Schreiben Sie Console.r, damit sich das IntelliSense-Fenster öffnet, wie es die folgende Abbildung zeigt. (Wir haben hier vermutet, dass wenn es eine Write-Anweisung gibt, mit der Informationen ausgegeben werden, die Methode zum Einlesen Read im Namen hat.)
Abbildung 4.1 Im Tooltipp-Fenster informiert Sie IntelliSense über die Signatur der in der Liste markierten Methode
Und wie Sie sehen, liegen wir mit der Vermutung nicht falsch. Die Klasse Console enthält drei verschiedene Methoden, die mit Read beginnen: Read, ReadKey und ReadLine. Markieren Sie nacheinander die drei Methodennamen in der geöffneten Liste und achten Sie dabei auf das Tooltipp-Fenster, in dem Sie eine kurze Beschreibung zur Funktionalität der Methode finden. Die Methoden Read und ReadKey sind für unsere Zwecke ungeeignet, da beide Methoden jeweils nur einen Tastendruck entgegennehmen. Da es sein kann, dass die Anwender unseres Rechners mehrstellige Zahlen addieren wollen, benötigen wir die Methode ReadLine, die die nächste Zeile (in der auch mehrere Zahlen enthalten sein können) einliest.
Die erste Zeile im gelben Tooltipp-Fenster zeigt die sogenannte Methodensignatur an. Die Methodensignatur besteht aus dem Namen der Methode (hier also Console.ReadLine), dem Rückgabewert, das ist der Datentyp, den die Methode zurückgibt (hier also string), und, falls an die Methode Werte übergeben werden, den Datentyp und die Reihenfolge dieser Werte, die Parameter genannt werden. Schauen Sie sich exemplarisch mit IntelliSense die Methodensignatur für Console.WriteLine an, einer Methode, die keinen Wert zurückgibt (dies wird durch das Schlüsselwort void angezeigt), der aber Parameter übergeben werden können.
Wir können nun den Programmcode schreiben, mit dem die Zahlen eingelesen werden, die das Programm addieren soll. Speichern Sie den Rückgabewert des ersten Aufrufs von ReadLine in der Variablen eingabe1 und den Rückgabewert des zweiten Aufrufs in der Variablen eingabe2 ab. Der Programmcode sieht danach folgendermaßen aus:
static void Main()
{
Console.WriteLine("Geben Sie den ersten Operanden ein ");
eingabe1 = Console.ReadLine();
Console.WriteLine("Geben Sie den zweiten Operanden ein ");
eingabe2 = Console.ReadLine();
}Wenn Sie versuchen, das Programm zu erstellen (drücken Sie F6 oder wählen Sie im Menü Erstellen/Projektmappe erstellen), erhalten Sie im Fehlerfenster zwei Meldungen mit dem Text: »Der Name Bezeichner ist im aktuellen Kontext nicht vorhanden.«, wobei anstelle von Bezeichner die Variablennamen eingabe1 und eingabe2 ausgegeben werden. Erinnern Sie sich: Vor der Verwendung von Variablen, müssen diese deklariert werden; das haben wir bisher noch nicht getan.
Generell gilt in der Programmiersprache C#, dass bei einer Zuweisung der Wert des Ausdrucks auf der linken Seite des Gleichheitszeichens den gleichen Datentyp besitzen muss, wie der Ausdruck auf der rechten Seite. (Genau genommen gibt es von dieser Regel auch kleine Ausnahmen; diese spielen aber im aktuellen Zusammenhang keine Rolle. Mehr hierzu ab „Typumwandlung im Überblick“ im Abschnitt über Typumwandlungen.) Aufgrund der Informationen des Tooltipp-Fensters von IntelliSense (siehe Abbildung 4.1) wissen wir, dass ReadLine einen Wert des Datentyps string zurückgibt. Diese beiden Informationen im Hinterkopf behaltend, deklarieren wir nun noch die beiden Variablen des Datentyps string.
static void Main()
{
string eingabe1, eingabe2;
Console.WriteLine("Geben Sie den ersten Operanden ein ");
eingabe1 = Console.ReadLine();
Console.WriteLine("Geben Sie den zweiten Operanden ein ");
eingabe2 = Console.ReadLine();
}Versuchen Sie, ob sich das Programm erstellen lässt (drücken Sie F6 oder wählen Sie den Befehl Erstellen/Projektmappe erstellen) und Sie sehen: es klappt.
So weit, so gut. Fehlt jetzt nur noch die Addition und die Ausgabe der Berechnung. Verwenden Sie den Operator +, um die Addition durchzuführen, und die mittlerweile gut bekannte Methode Console.WriteLine, um das Ergebnis auszugeben. Das fertige (wenn auch, wie Sie gleich sehen werden, nicht funktionale) Programm, sieht so aus:
static void Main()
{
string eingabe1, eingabe2;
Console.WriteLine("Geben Sie den ersten Operanden ein ");
eingabe1 = Console.ReadLine();
Console.WriteLine("Geben Sie den zweiten Operanden ein ");
eingabe2 = Console.ReadLine();
Console.WriteLine("Die Summe ist: " + eingabe1 + eingabe2);
}Starten Sie das Programm, geben Sie wie gebeten die Operanden ein und schauen Sie sich das angezeigte Ergebnis an.
Das macht noch keinen guten Eindruck. Anstatt die Summe der beiden eingegebenen Zahlen zu berechnen und anzuzeigen, werden die beiden Operanden einfach aneinandergehängt. Der Grund dafür ist, dass der Operator + verschiedene Dinge erledigt, und zwar in Abhängigkeit davon, auf welchen Datentyp er angewendet wird.
Lassen Sie uns die Codezeile
Console.WriteLine("Die Summe ist: " + eingabe1 + eingabe2);
etwas genauer unter die Lupe nehmen. Beim Aufruf von WriteLine wird der Operator + zweimal verwendet. Im ersten Fall soll er verwendet werden, um die Zeichenkette “Die Summe ist:” mit dem Ergebnis der (vermeintlichen) Addition zu verbinden; bei der zweiten Verwendung würden wir gern die beiden Zahlen addieren lassen. Das Problem ist jedoch, dass es sich bei eingabe1 und eingabe2 nicht um Zahlen handelt, sondern um Variablen, in denen Strings, also Zeichenketten enthalten sind, wie wir es bei der Deklaration dieser Variablen angegeben haben. Wird der Operator + bei Zeichenketten verwendet, werden diese hierdurch aneinandergehängt. So gesehen, macht die kleine Anwendung genau das, was wir programmiert haben. Um die Summe zu erhalten, müssen wir aus den Zeichenketten eingabe1 und eingabe2 Zahlen machen und dann den +-Operator anwenden. Wird der Operator + auf Zahlen angewendet, werden diese auch addiert. Wie Sie diese Umwandlung vornehmen können, beschreibt der nächste Abschnitt.
Hinter allen Datentypen, die Sie in C# verwenden können, verbergen sich Klassen (mehr dazu weiter hinten in diesem Kapitel). Die Klassen für die Datentypen besitzen Methoden, die Sie aufrufen können, wie Sie es bisher beispielsweise mit der Methode WriteLine der Klasse Console gemacht haben. Alle Klassen, die Ganzzahlen darstellen, besitzen eine Methode mit dem Namen Parse, mit der eine Zeichenkette, die eine Zahl darstellt, in eine Variable des zugehörigen Integer-Datentyps konvertiert werden kann.
Die allgemeine Syntax der Parse-Methode lautet:
variable = datentypDerVariablen.Parse(Eingabezeichenkette);
Mit diesen Informationen kommen wir einen Schritt weiter.
Deklarieren Sie zwei Variablen des Typs int und nennen Sie diese operand1 und operand2.
static void Main()
{
string eingabe1, eingabe2;
int operand1, operand2;
Console.WriteLine("Geben Sie den ersten Operanden ein ");
eingabe1 = Console.ReadLine();
Console.WriteLine("Geben Sie den zweiten Operanden ein ");
eingabe2 = Console.ReadLine();
Console.WriteLine("Die Summe ist: " + eingabe1 + eingabe2);
}Erstellen Sie eine neue Codezeile hinter der Zeile, in der die erste Zahl eingelesen wird, verwenden Sie die Methode Parse des Datentyps int, um die Zeichenkette eingabe1 in eine Zahl konvertieren zu lassen, und weisen Sie das Ergebnis der Variablen operand1 zu. Dieser Vorgang wird explizite Typumwandlung genannt, da Sie ausdrücklich angeben, welche Konvertierung vorgenommen werden soll. (Es gibt auch die sogenannte implizite Typumwandlung, die der Compiler automatisch vornimmt; wir kommen hierauf in Kürze zurück.)
static void Main()
{
string eingabe1, eingabe2;
int operand1, operand2;
Console.WriteLine("Geben Sie den ersten Operanden ein ");
eingabe1 = Console.ReadLine();
operand1 = int.Parse(eingabe1);
Console.WriteLine("Geben Sie den zweiten Operanden ein ");
eingabe2 = Console.ReadLine();
Console.WriteLine("Die Summe ist: " + eingabe1 + eingabe2);
}Im Code von Schritt 9 befinden sich der Aufruf von ReadLine und von Parse in zwei verschiedenen Anweisungen bzw. Codezeilen. Sie können die beiden Aufrufe auch miteinander kombinieren und in einer Codezeile schreiben. Ändern Sie die Zeile nach dem zweiten Aufruf von Console.WriteLine wie folgt ab und löschen Sie anschließend die Deklaration der Variablen eingabe2, die dann nicht mehr benötigt wird.
static void Main()
{
string eingabe1;
int operand1, operand2;
Console.WriteLine("Geben Sie den ersten Operanden ein ");
eingabe1 = Console.ReadLine();
operand1 = int.Parse(eingabe1);
Console.WriteLine("Geben Sie den zweiten Operanden ein ");
operand2 = int.Parse(Console.ReadLine());
Console.WriteLine("Die Summe ist: " + eingabe1 + eingabe2);
}
Sie sehen an der zweiten fett hervorgehobenen Zeile, dass Sie als Parameter für die Methode Parse, die ein Argument des Typs string erwartet, auch direkt den Aufruf von Console.ReadLine programmieren können, da diese Methode einen string-Wert zurückgibt. Der Compiler erkennt, dass er die Methoden »von innen nach außen« aufrufen muss; also zuerst ReadLine und erst danach Parse.
Die letzte Korrektur, die Sie vornehmen müssen, ist die letzte Codezeile im Programm. Damit auch (hoffentlich) wirklich die Zahlen addiert werden und die Summe ausgegeben wird, ersetzen Sie dort die Variablen eingabe1 und eingabe2 durch die Variablen operand1 und operand2.
static void Main()
{
string eingabe1;
int operand1, operand2;
Console.WriteLine("Geben Sie den ersten Operanden ein ");
eingabe1 = Console.ReadLine();
operand1 = int.Parse(eingabe1);
Console.WriteLine("Geben Sie den zweiten Operanden ein ");
operand2 = int.Parse(Console.ReadLine());
Console.WriteLine("Die Summe ist: " + operand1 + operand2);
}Eigentlich sollte jetzt alles funktionieren. Probieren Sie es aus, starten Sie das Programm und überprüfen Sie, ob nun die Summe korrekt berechnet und angezeigt wird.
Es funktioniert noch immer nicht (wir sind aber kurz vor dem Ziel, bitte noch einen kleinen Moment Geduld). In der letzten Zeile des Programms macht uns ein Mechanismus einen Strich durch die Rechnung, der implizite Typumwandlung genannt und vom Compiler vorgenommen wird. Console.WriteLine erwartet einen Parameter des Typs string. Der in Anführungszeichen eingeschlossene Text ist bereits eine Zeichenkette, der Compiler braucht also hier nichts zu machen. operand1 und operand2 besitzen aber den Typ int; damit ein int mit Console.WriteLine ausgegeben werden kann, muss das int erst in eine Zeichenkette konvertiert werden. Diese Konvertierung nimmt der Compiler automatisch vor (daher implizite Typumwandlung), was dazu führt, dass der Operator + immer noch auf drei Zeichenketten angewendet wird. Daher ist die Ausgabe noch immer nicht das Ergebnis der Addition.
Damit das Programm richtig funktioniert, müssen wir den Compiler darüber informieren, dass er für operand1 und operand2 keine implizite Typumwandlung vornehmen, sondern stattdessen die beiden int-Werte addieren soll. Hierzu verwenden wir runde Klammern. Ändern Sie die letzte Zeile des Quellcodes wie folgt ab:
static void Main()
{
...
Console.WriteLine("Die Summe ist: " + (operand1 + operand2));
}
Das Einfassen in die runden Klammern führt dazu, dass der Compiler zuerst die Addition der beiden Zahlen vornimmt (Ausdrücke in Klammern werden zuerst ausgewertet). Anschließend erkennt der Compiler, dass die berechnete Summe, die computerintern als Zahl vorliegt, ausgegeben werden soll. Hier greift dann wieder die implizite Typumwandlung von int in string: Nachdem die Zahl als Zeichenkette vorliegt, wird sie mit dem Text »Die Summe ist: « verknüpft, ausgegeben, und das Programm funktioniert nun so, wie es soll.
Wie Sie im vorhergehenden Beispiel gesehen haben, ist es manchmal erforderlich, Variablen eines Datentyps in einen anderen Datentyp umzuwandeln. Drei Fälle lassen sich hier unterscheiden, für die Sie im Ordner mit den Beispielen ein kleines Projekt mit dem Namen Kap04\TypeConversion finden:
Um eine Zahl, die in einer Stringvariablen vorliegt, in eine Variable eines der Zahlentypen umzuwandeln, verwenden Sie die Parse-Methode des gewünschten Zahlendatentyps. Das sieht dann beispielsweise so aus:
string intString = "4", doubleString = "3,3"; int intNumber; double doubleNumber; intNumber = int.Parse(intString); doubleNumber = double.Parse(doubleString);
Beachten Sie bei den nicht ganzzahligen Datentypen, dass im String das Dezimaltrennzeichen verwendet sein muss, das auch in den Ländereinstellungen auf dem jeweiligen PC definiert ist. Wenn im obigen Beispiel das Komma als Dezimaltrennzeichen definiert ist und Sie double-String mit 3.3 initialisieren, wird hieraus bei der Umwandlung in eine Zahl der Wert 33.0.
Alle Datentypen, die eine Zahl darstellen, besitzen eine Methode mit dem Namen ToString, mit der die Zahl in eine Zeichenkette umgewandelt werden kann. Hierzu ein Beispiel:
int intNumber = 40; string s = intNumber.ToString();
Geben Sie den Namen der Variablen an, die umgewandelt werden soll, verwenden Sie dann die Methode ToString und weisen Sie den Rückgabewert beispielsweise einer Variablen des Typs string zu. Sie können ToString bei allen Datentypen, in denen eine Zahl gespeichert wird, verwenden.
Die dritte mögliche Typumwandlung besteht darin, eine Zahl eines Datentyps in einen anderen umzuwandeln. Hierbei müssen Sie beachten, dass der Datentyp, in den umgewandelt wird, die umzuwandelnde Zahl aufnehmen kann (siehe Tabelle 4.1 und Tabelle 4.2). Wenn der Wertebereich des Zieldatentyps größer ist, reicht es aus, einfach eine Zuweisung zu verwenden. Der Compiler nimmt dann eine implizite Typumwandlung vor. Wenn der Wertebereich des Zieldatentyps kleiner ist und damit bei der Umwandlung Verluste auftreten können, lässt sich der Code nicht kompilieren; es sei denn, Sie nehmen eine explizite Typumwandlung vor, indem Sie den Zieldatentyp, von runden Klammern eingefasst, vor den Namen der umzuwandelnden Variablen schreiben. Auch wenn dann ein Informationsverlust auftritt, lässt sich der Code so kompilieren und ausführen. Der Compiler geht bei einer expliziten Typumwandlung davon aus, dass Sie sich über den möglichen Informationsverlust im Klaren sind.
Hier ein paar Beispiele:
// Der Wertebereich des Zieldatentyps ist größer, die Umwandlung kann ohne Verluste vorgenommen werden. // Der Compiler nimmt eine implizite Typkonvertierung vor. short a = 35; int b = a; int c = 3; double d = c; // Die zweite Zeile lässt sich nicht kompilieren, da die implizite Typumwandlung möglicherweise // mit dem Verlust von Informationen einhergeht. Der Compiler informiert Sie hierüber in dem Fehlerfenster. int e = 32000; short d = e; // Wenn Sie eine explizite Typumwandlung vornehmen, erlaubt der Compiler, trotz möglichen Informations- // verlustes, die Typkonvertierung. int f = 32000; short g = (short) f;