Wir haben uns in der letzten Lektion mit Ausgaben mit Hilfe der STL beschäftigt. Warum nun also nicht auch Eingaben? Generell wäre dies sicherlich sinnvoll. Nur wie soll man eine Eingabe realisieren? Was passiert mit der Eingabe eines Benutzers? Man wird sie wohl irgendwo speichern müssen. Bevor wir uns also mit Eingaben beschäftigen, müssen wir erst einmal eine Möglichkeit haben, Werte in Form von Zahlen, Buchstaben und evtl. ganzen Wörtern festzuhalten.
Zunächst einmal sollte man wissen, dass man erst einmal bestimmen muss, wieviel Speicher man für einen Wert man benötigt. Keine Angst, das ist nicht so kompliziert, wie es sich anhört. Wir unterscheiden zunächst zwischen folgenden so genannten "Datentypen":
| Datentyp | Größe in Byte | Wertebereich / Funktion |
|
int |
bei WIN32 4 | -2^31 bis 2^31 - 1 (Ganzzahl) |
| long | 4 | -2^31 bis 2^31 - 1 (Ganzzahl) |
| short | 2 | -2^15 bis 2^15 - 1 (Ganzzahl) |
| double | 8 | Kommazahl mit doppelter Genauigkeit |
| float | 4 | Kommazahl mit einfacher Genauigkeit |
| char | 1 | -2^7 bis 2^7 - 1 wird für den ANSI-Zeichensatz verwendet (Buchstabe bzw Ganzzahl) |
| bool | 1 | nimmt nur 2 Werte an 'true' (wahr) oder 'false' (falsch) |
Man kann bei den Datentypen ('int', 'long', 'short' und 'char') noch den Bezeichner 'unsigned' verwenden. Dadurch liegt der Wertebereich ausschließlich im Positiven. Das sieht dann wie folgt aus:
| Datentyp | Größe in Byte | Wertebereich / Funktion |
|
unsigned int |
bei WIN32 4 | 0 bis 2^32 - 1 (Ganzzahl) |
| unsigned long | 4 | 0 bis 2^32 - 1 (Ganzzahl) |
| unsigned short | 2 | 0 bis 2^16 - 1 (Ganzzahl) |
| unsigned char | 1 | 0 bis 2^8 - 1 wird für den ANSI-Zeichensatz verwendet |
Es gibt zwar auch den Bezeichner 'signed'. Er hat jedoch keine Auswirkung.
Möchte man im Programm nun Werte behalten sollte man sich zunächst einmal überlegen, wie groß der Wert höchstens sein könnte, ob er vielleicht nur positiv oder vielleicht eine Kommazahl ist. Möchte man beispielsweise das Alter einer Person im Programm festhalten, wäre eine negative Zahl nicht wirklich sinnvoll. Eine Kommazahl wäre nur dann zu gebrauchen, wenn außer den Jahren auch die Monate berücksichtigt werden müssen. Beschränkt man sich auf Ganzzahlen, so würde also ein 'unsigned char' vollkommen ausreichen, da man bezweifeln muss, dass ein Mensch älter als 2^8 - 1 = 255 Jahre alt wird.
Der Datentyp 'bool' ist insofern besonders, da er nur zwei Werte annimmt (wahr oder falsch). So kann man z.B. den Status an oder aus, die Antwort einer Frage ja oder nein festhalten. Auf den Datentyp werde ich noch früh genug eingehen.
Bleiben wir nun also bei unserem Beispiel und speichern das Alter von zwei Personen in einem Programm und geben diese aus. Wir nennen die Personen A und B. Wir benötigen zwei Werte, wobei wir uns aus oben genannten Gründen auf den Datentyp 'unsigned char' festgelegt haben. Wie kann man nun solche Werte mit Hilfe von Datentypen speichern? Man verwendet zu diesem Zweck so genannte Variablen. Bei Variablen legt der Programmierer Bezeichner fest, welche innerhalb eines gewissen Bereichs ihre Gültigkeit besitzen. Die Bezeichner, welche vom Programmierer ausgesucht werden - man wählt sie meist so aus, dass man anhand ihrer Bezeichnung den Zweck erkennen kann - sind innerhalb des Bereiches eindeutig.
Angenommen Person A ist 65 Jahre alt und Person B 66 Jahre. Wir benötigen nun 2 Variablen, wir nennen sie 'age_a' und 'age_b'. (Alter von Person A und Alter von Person B) Bezeichner von Variablen können beliebige Kombinationen von Buchstaben und Zahlen und dem Unterstrich sein, wobei allerdings einige Regeln zu beachten sind:
 | Variablennamen müssen mit einem Unterstrich oder mit einem Buchstaben anfangen also 'a3' oder '_a' aber nicht '3a' |
| Variablennamen dürfen nicht genauso wie schon definierte Bezeichner oder Schlüsselwörter (z.B. Datentypen aber auch 'main') benannt werden. |
| Es wird zwischen Groß- und Kleinschreibung unterschieden. Man könnte also durchaus eine Variable mit "Int" bezeichnen |
Wie verwendet man nun die sogenannten Variablen und wie weist man ihnen einen Datentyp zu? Angenommen wir wollen jetzt im Programm das Alter der ersten Person festlegen. Dann sieht das im Programm wie folgt aus:
unsigned char age_a; age_a = 65;
oder
unsigned char age_a = 65;
Im allgemeinen sieht das also so aus:
<Datentyp> <Variablenname>; (Deklaration) <Variablenname> = <Wert>; (Initialisierung)
oder
<Datentyp> <Variablenname> = <Wert>;
Nicht zu vergessen ist wieder einmal das Semikolon am Ende einer jeden Anweisung (Deklaration und Initialisierung). Die Variable 'age_a' wird also als "unsigned char" deklariert und mit '65' initialisiert.
Möchte man 'age_b' auch noch deklarieren und mit 26 initialisieren so kann man dies genauso vornehmen wie mit 'age_a':
unsigned char age_b; age_b = 66;
oder
unsigned char age_b = 66;
Man kann beide Variablen aber auch gleichzeitig deklarieren und initialisieren:
unsigned char age_a, age_b; age_a = 65; age_b = 66;
oder
unsigned char age_a = 65, age_b = 66;
oder allgemein:
<Datentyp> <Variablenname_1>, <Variablenname_2>, (...), <Variablenname_n>; <Variablenname_1> = <Wert_1>; <Variablenname_2> = <Wert_2>; (...) <Variablenname_n> = <Wert_n>;
oder
<Datentyp> <Variablenname_1> = <Wert_1>, <Variablenname_2> = <Wert_2>, (...), <Variablenname_n> = <Wert_n>;
Jetzt können wir ein Programm schreiben, welches das Alter beider Personen ausgibt. Sie können das Programm genauso erstellen wie das letztere (Als Namen können sie hier Age wählen). Die Datei "main.cpp" könnte dann in etwa so aussehen.
#include <iostream.h>
void main()
{
unsigned char age_a = 65, age_b = 66;
cout << "Alter von Person A: " << age_a << endl;
cout << "Alter von Person B: " << age_b << endl;
}
Führt man das Programm aus erhält man folgende Ausgabe:
Erwartet haben wir dies sicher nicht, aber keine Angst dies ist kein schwerwiegender Fehler. Bei der Anweisung 'cout' liegt der Hase im Pfeffer. Der Datentyp "char" ist zwar eine Ganzzahl wird aber von der 'cout' als Buchstabe interpretiert. (char stammt übrigens von character). Und 65 und 66 sind zufälligerweise genau die ASCII-Codes für 'A' und 'B'. Dazu später mehr!
Beheben ließe sich das Problem ganz einfach, indem man den Wertebereich von "char" auf "short" erhöht. Dann sollte es erwartungsgemäß laufen.
Jetzt ließe sich das Programm noch soweit verändern, dass der Benutzer das Alter von A und B selbst eingeben kann. Zu diesem Zweck gibt es das Gegenstück zu 'cout', welches auf den Namen 'cin' hört.
Der zugehörige Operand ist aber nicht '<<' sondern '>>'. Im allgemeinen sieht das dann so aus:
cin >> <Variable>;
Die Datei "main.cpp" ließe sich dann folgendermaßen abändern (Änderungen sind grau):
#include <iostream.h>
void main()
{
unsigned short age_a, age_b;
cout << "Geben Sie das Alter folgender Personen ein:" << endl;cout << "Person A: "; cin >> age_a;
cout << "Person B: "; cin >> age_b;
cout << "Alter von Person A: " << age_a << endl; cout << "Alter von Person B: " << age_b << endl; }
Führen Sie das Programm aus können Sie das Alter beider Personen selbst eingeben. Später werden die Daten wieder ausgegeben.
Die bisherigen Variablen wurden innerhalb einer Methode (Methode: 'main') deklariert, d.h. es handelt es sich hierbei um eine lokale Variable. Auf sie kann nur innerhalb der Methode zugegriffen werden. Legt man sie außerhalb der Methode an, dann handelt es sich um eine globale Variable, die dann von jeder Funktion aufgerufen werden kann.
//globale Variablen
int g_i = 5;
double g_d = 5.9;
void main()
{
//lokale Variablen
int i = 7;
double d = 3.7;
//Zugriff auf globale Variable
g_i = i;
d = g_d;
}
Globale Variablen unterscheiden sich bezüglich der lokalen also lediglich im Hinblick auf den Gültigkeitsbereich. Verwenden lassen sie sich genauso.
Globale Variablen sind dennoch möglichst zu vermeiden, da man schnell den Überblick verliert, da von überall auf sie zugegriffen und sie somit auch von überall verändert werden kann.
Bei nahezu jedem Datentyp lässt sich das Schlüsselwort 'const' ergänzen, um festzulegen, dass es sich bei der angelegten Variablen um eine Konstante handelt, die im nachhinein nicht mehr veränderbar ist. Das bedeutet auch, dass es mit der Deklaration auch initialisiert werden muss:
const <Datentyp> <Variablenname> = <Wert>;
Beispielsweise ließe sich innerhalb eines Programms die Konstante 'pi' festlegen:
const double pi = 3.14159;
Eine nachträgliche Änderung einer konstanten ist grundsätzlich nicht möglich:
const double pi = 3.14159; pi = 3.141592; //C2166: L-Wert gibt ein konstantes Objekt an
Auch Konstanten lassen sich natürlich global deklarieren, d.h. man kann sie zwar von überall lesen ihren Wert aber nicht verändern.
Neben den Datentypen und den Variablen haben sie nun auch die Eingabe kennengelernt. Für weitere Lektionen sollte Ihnen die Deklaration und Initialisierung von Variablen ein Begriff sein. Auch die Deklaration von Konstanten sollte bekannt sein. Die Eingaben werden in der Form innerhalb der nächsten Lektion weiter verwendet. In den nächsten Lektionen werden sie weitere von den Basisdatentypen abgeleitete Datentypen kennenlernen. Zunächst werden wir uns aber mit Operationen beschäftigen welche den Wert einer Variablen verändern kann.
