3. Einfache und fortgeschrittene Datentypen

3.1 Einfache Datentypen und Zuweisungen

Wir haben gesehen, dass "int" für einen Zahlenwert steht. Damit ist "int" ein so genannter Datentyp. Es gibt ein paar wichtige grundsätzliche Datentypen:

int
"Integers" sind ganze Zahlen. Eine Variable vom typ "int" speichert immer eine ganze Zahl. Dabei gibt es Grenzen für die Zahl, welche gespeichert werden soll. In einer bestimmten Variablen namens INT_MAX ist der größtmögliche Wert für ein "int" gespeichert, in einer Variable namens INT_MIN der kleinstmögliche. Dieses Programm gibt euch die Werte für euer System aus:

#include <iostream>

using namespace std;

int main(){
    cout << "Die groesste Integer - Zahl: " << INT_MAX << endl;
    cout << "Die kleinste Integer - Zahl: " << INT_MIN << endl;
    cin.get();
    return 0;
}

Für größere Zahlen benutzt man den Datenyp long, falls der auf dem gegebenen System größere Zahlen als "int" halten kann - bei mir ist INT_MAX allerdings genauso groß wie LONG_MAX. Für kleinere Zahlen gibt es den Datenyp short, dessen maximaler Wert in der Konstante SHRT_MAX gespeichert ist. (8 Buchstaben nicht zu überschreiten war vielleicht auch mal sinnvoll... auf jeden Fall heißt das Ding SHRT_MAX und nicht SHORT_MAX.) "Short" wird allerdings kaum noch verwendet, da der Unterschied im Speicherplatzbedarf bei den meisten Anwendungen kein Problem mehr darstellt.
Wenn ihr wisst, das ihr große Zahlen verwenden möchtet, aber nur positive, könnt ihr den Bereich der möglichen Zahlen mit dem Schlüsselwort unsigned in den Bereich der positiven Zahlen verschieben und so doppelt so viele, aber eben nur positive Zahlen speichern. (Beispiel: unsigned int meineZahl;)

float
Um auch Kommazahlen speichern zu können, benutzt man "float". Für genauere Kommazahlen gibt's außerdem den Typ double.

char
"char" steht für "character" (= "Buchstabe"). Eine variable vom Typ char speichert somit einen Buchstaben. Dieser muss bei der Zuweisung in einfachen Anführungszeichen angegeben werden, aber das seht ihr gleich noch.

string
Strings sind Aneinanderreihungen von chars, Zeichenketten eben. Strings werden immer in Gänsefüßchen angegeben, auch wenn sie nur ein Zeichen enthalten. "Hello Nerds!" ist ein Beispiel für einen String.

bool
"Bool" ist der Name eines Mathematikers, nach dem die so genannte "boolesche Algebra" benannt ist. Dabei geht es um das Rechnen mit Wahrheitswerten - eine Variable kann somit nur den Wert "wahr" oder den Wert "falsch" haben. Genau so eine Art von Variable könnt ihr mit dem Typ "bool" anlegen. "Wahr" wird dann als "1" oder "true" angegeben, "falsch" als "0" oder "false". (Ihr seht das noch im Beispiel!)

Zuweisungen
Wenn Ihr eine Variable anlegen wollt, braucht ihr nur den Datentyp anzugeben und anschließend einen Namen. Etwa so:

int meineZahl;

Es handelt sich um eine Anweisung, denn ihr habt dem Programm gesagt einen gewissen Bereich im Speicher zu reservieren, um dort die integer - Zahl "meine Zahl" zu speichern. Stellt euch das Ganze vor wie ein Fach, auf das das Programm "meineZahl" schreibt, und in das ihr eine Zahl ablegen und jederzeit wieder rausholen könnt. Um der Zahl einen Wert zuzuweisen, benutzt man ein einfaches Gleichheitszeichen:

int meineZahl;
meineZahl = 12;

Da es sich um eine Anweisung (genauer: eine Zuweisung) handelt, muss die Zeile wieder mit einem Semikolon enden. Das Ganze kann man auch in einem Schritt machen:

int meineZahl = 12;

Dabei müsst ihr beachten, dass die Variable auf der linken Seite des Gleichheitszeichens immer den Wert auf der rechten Seite des Gleichheitszeichens zugewiesen bekommt. ("12 = meineZahl" ginge also nicht!) Das ganze geht auch mit Variablen:

int meineZahl = 12;
int meineAndereZahl = 7;
meineZahl = meineAndereZahl;

Durch die Zuweisung haben jetzt beide Zahlen den Wert 7!


Zuweisungen finden immer von Rechts nach Links statt.


Das Anlegen einer Variablen (oder Funktion) nennt man Deklaration. Das erste Mal, wenn eine Variable mit einem Wert belegt wird, ist die so genannte Initialisierung. Beides kann man auch gleichzeitig für mehrere Variablen vom gleichen Typ machen, nämlich indem man die Variablen durch Kommas (für Germanisten: Kommata) trennt und das ganze wie immer mit einem Semikolon abschließt:

int a = 12, b = 235, c = 5237, d, e = 23;

Hinweis:
In diesem Beispiel hat "d" noch keinen Wert bekommen. Das heißt aber nicht, dass es einen Fehler gibt, wenn ihr jetzt auf d zugreift, sondern bloß, dass d immernoch den Wert hat, der vorher an der Stelle im Speicher lag, wo d sich jetzt eingenistet hat. Das kann 0 sein, muss es aber nicht.

Hier ein kleines Beispielprogramm zu dem, was wir bisher hatten:

#include <iostream>

using namespace std;

int main(){
    int attacke = 12, parade = 8;
    float goldvorrat = 23.65;
    char charakterklasse = 'k';
    bool istMagiebegabt = true;
    string name = "Irenicus";

    cout << "Attackewert: " << attacke << endl;
    cout << "Paradewert: " << parade << endl;
    cout << "Charakterklasse: " << charakterklasse << endl;
    cout << "Magiebegabt? " << istMagiebegabt << endl;
    cout << "Name: " << name << endl;

    cin.get();
    return 0;
}

Das Programm initialisiert ein paar Variablen und gibt sie dann aus, jeweils mit einer kleinen Anmerkung um was es sich handelt. Natürlich könnten wir das auch ohne Variablen machen, indem wir direkt in die Gänsefüßchen in der "cout" - Zeile schreiben, was ausgegeben werden soll - aber wenn man sich vorstellt, dass das Programm größer ist und vielleicht noch viele andere Ausgaben mit diesen Werten erzeugt, wird klar, warum diese variante besser ist: wenn wir unseren Charakter z.B. anders benennen wollen, brauchen wir nur an einer Stelle, nämlich bei "name = ..." was zu ändern, und schon sind werden Ausgaben dementsprechend angepasst.

Wenn wir einen Zahlenwert mit einer anderen Zahl addieren wollen, geht das über das Pluszeichen:

int attacke = 12 + 3;

Kein Problem, attacke ist jetzt 15. Wenn wir auf einen Wert etwas draufaddieren wollen, können wir das aber auch so machen:

int attacke = 12;
attacke = attacke + 3;

Dabei wird "attacke" der vorherige Wert zugewiesen, plus 3. Dafür gibt es eine eigene, kürzere Schreibweise:
int attacke = 12;
attacke += 3;

Wenn man den Wert nur um 1 erhöhen will, geht das noch kürzer:

int attacke = 12;
attacke++;

"attacke" hat jetzt den Wert 13. Probiert die Varianten mal aus! Genauso geht das Ganze auch mit "-", "*" ("mal", Multiplikation) und "/" ("geteilt", Division):

int attacke = 12;
attacke /= 2;
attacke *= 3;
attacke--;
attacke -= 2;

Probiert mal, bevor ihr den nächsten Abschnitt lest, zu raten (besser: herauszufinden ;) welchen wert "attacke" nach diesen ganzen Anweisungen hat. Ihr könnt euren Tipp mit der Konsolenausgabe kontrollieren:

#include <iostream>

using namespace std;

int main(){
    int attacke = 12;
    attacke /= 2;
    attacke *= 3;
    attacke--;
    attacke -= 2;
    int parade = 8;
    float goldvorrat = 23.65;
    char charakterklasse = 'k';
    string name = "Irenicus";

    cout << "Attackewert: " << attacke << endl;
    cout << "Paradewert: " << parade << endl;
    cout << "Charakterklasse: " << charakterklasse << endl;
    cout << "Name: " << name << endl;

    cin.get();
    return 0;
}

Hier die Auflösung: Die erste Zeile weist "attacke" den Wert 12 zu - soweit klar. Die zweite Zeile bedeutet ausgeschrieben "attacke = attacke / 2", der Wert wird also durch 2 geteilt.
Wichtig: Bei int - Divisionen wird immer abgerundet, also ist 5 / 2 = 2 und 1 / 2 = 0!

Das Ergebnis ist 6 - nun wird das ganze mit 3 multipliziert (=18), dann wird eins abgezogen, durch die Anweisung "attacke--" (- analog zum Beispiel oben mit "attacke++;"). Nun kommt die letzte Zeile "attacke -= 2", hier wird attacke = attacke - 2, d.h. aus 17 wird... 15!

Wichig ist noch, dass es für den "++" - und den "--" - Operator zwei je Schreibweisen gibt:

int attacke = 12;
attacke--;
attacke++;
--attacke;
++attacke;

Der Unterschied ist erst dann zu sehen, wenn um den Ausdruck "attacke++" oder "++attacke" noch eine Anweisung drum herum steht. Im Fall von "attacke++" wird dann erst die Anweisung drum herum ausgeführt, im Fall von "++attacke" wir der Wert erst um eins erhöht und dann erst die Anweisung ausgeführt. Für "--" funktioniert das Ganze genauso. Beispiel gefällig?

int attacke = 12;
int parade = 8;
parade = attacke++;

"parade" erhält jetzt den Wert von "attacke", und erst dann wird "attacke" um eins erhöht. "parade" ist dann also 12, "attacke" ist 13. Anders siehts aus, wenn ihr "++attacke" verwendet:

int attacke = 12;
int parade = 8;
parade = ++attacke;

In dem Fall wird "attacke" zuerst erhöht und dann auch auf die Variable "parade" übertragen - dann sind beide Werte 13.
[top]

3.2 Zeiger und Adressen

Jetzt kommt ein kurzer Abschnitt über das Gemeinste was C++ zu bieten hat, nämlich Zeiger. Zeiger sind, wie der Name schon sagt, Verweise auf eine Speicheradresse, wo dann wiederum in der Regel ein Wert liegt. Die Vorteile von Zeigern werden erst deutlich, wenn man Werte an Funktionen übergibt, deshalb werde ich im Abschnitt über Funktionen nochmal drauf zu sprechen kommen. Einen Zeiger legt man an wie eine Variable, nur mit einem Sternchen als Zeichen dafür, dass er keine Variable vom angegebenen Typ ist, sondern nur auf eine vom angegebenen Typ zeigen kann. Bei der Deklaration zeigt der Zeiger erstmal nirgendwo hin.

int* zeiger;

Soweit ist hoffentlich alles klar. Es ist auch möglich, das Sternchen auf die Seite des Variablennamens zu schreiben:

int *zeiger, attacke = 12;

Jetzt gilt das Sternchen nur für den Zeiger und nicht für "attacke". wenn wir den Zeiger jetzt auf etwas zeigen lassen wollen, brauchen wir eine (virtuelle) Speicheradresse, auf die gezeigt werden soll. Die Adresse einer Variablen kann man sich mit einem bestimmten Zeichen, nämlich dem "&", holen. Das geht zum Beispiel so:

int *zeiger, attacke = 12;
int parade = 8;
zeiger = ¶de;

Merkt euch also: Mit "&" holt man sich die Speicheradresse einer Variablen. Da der zeiger diese Adresse enthält, führt eine Ausgabe des zeigers auch zur Ausgabe der Adressse:

int *zeiger, attacke = 12;
int parade = 8;
zeiger = ¶de;
cout << zeiger << endl;

Probierts mal aus! (Die Speicheradresse wird mit "0x" beginnend ausgegeben, das heißt das die folgende Nummer im Hexadezimalsystem steht.) Wir haben also irgendeine kryptische Nummer ausgegeben bekommen, die uns überhaupt nichts bringt. Wie kommen wir denn jetzt an den Wert der Variablen, auf die der Zeiger verweist? Auch dafür gibt es einen Operator, der leider wiedermal das Sternchen ist. Das steht also, je nach Zusammenhang, für die Deklaration eines Zeiger, die Multiplikation, oder eben, wie in der letzten Zeile des folgenden Beispiels, für das Holen der Variablen, auf die der Zeiger verweist:
int *zeiger, attacke = 12;
int parade = 8;
zeiger = ¶de;
cout << *zeiger << endl;

Nur ein Sternchen mehr als oben, und schon bekommen wir statt der Adresse des Zeigers den wert, auf den er zeigt, ausgegeben, in diesem Fall den wert von "parade". Merkt euch also hier: Mit * holt man sich den Wert, auf den ein Zeiger zeigt.
Also... &holt Adresse zur Variablen... * holt Wert zum Zeiger... . Interessant wird das ganze nachher bei den Funktionen und Objekten. Nach dem Abschnitt über Referenzen wirds wieder etwas praktischer, versprochen... ;)
[top]

3.3 Referenzen

Referenzen sind so etwas ähnliches wie Zeiger, werden aber im Programmcode anders behandelt, nämlich einfacher. Die C++ - Leute haben gesehen, dass dieses ganze Adressen - holen und Variablen - zum - Zeiger - holen leicht verwirrend sein kann und daher die Referenzen eingeführt. Dabei ist ein Zeiger ja eigentlich auch eine "Referenz" (also ein "Verweis") auf ein Objekt, aber man musste ja irgeneine treffenden Bezeichnung für das neue Konstrukt finden. Referenzen haben die Besonderheit, dass sie direkt initialisiert werden müssen. Das Zeichen für eine Referenz ist... das hier: & ... Verwirrung... . Wenn ihr eine Adresse holen wollt verwendet ihr das Zeichen ebenfalls, wie wir oben gesehen haben, aber wenn man es hinter den Namen des Datentyps bei der Deklaration und Initialisierung einer Referenzvariablen setzt, heißt es eben, dass es sich bei der angelegten Variable um eine Referenz handelt. Beispiel:

int parade = 8;
int& referenz = parade;
cout << referenz << endl;

Wie gesagt, ihr müsst die Referenz sofort initialisieren, in diesem Fall wurde die Referenz mit "parade" initialisiert. Die Ausgabe gibt euch somit auch direkt "parade" aus. Wie man sieht, verhält sich die Referenz wie eine Kopie der Variablen - sie ist jedoch ein Zeiger. Der Unterschied wird im folgenden Beispiel deutlich:

int parade = 8;
int& referenz = parade;
parade = 17;
cout << referenz << endl;

Wir haben die Referenz als Verweis auf "parade" angelegt und danach nur "parade" (nicht "referenz"...) verändert - trotzdem hat sich der Wert für "referenz" mitverändert, wie die Ausgabe beweist. Referenzen können also wie einfache Variablen behandelt werden, sind aber keine Kopien sondern Verweise. Auch auf Referenzen und ihren eigentlichen Nutzen werde ich im Abschnitt über Funktionen nochmal eingehen.
[top]

3.4 Arrays

Bisher haben wir Werte immer einzeln verwaltet, d.h. für eine Reihe von Werten haben wir immer auch eine Reihe von Variablen benutzt. Das wir allerdings auf die Dauer ziemlich umständlich.
Nehmen wir an, der Charakter in unserem fiktiven RPG hat einen Rucksack, ein Inventar. Das Inventar besteht aus 16 * 8 Feldern, auf denen Gegenstände abgelegt werden sollen. Die Gegenstände haben Nummern, anhand derer wir sie zuordnen können, z.B.:
0 = kein Gegenstand
1 = kleiner Heiltrank
2 = großer Heiltrank
3 = kleiner Manatrank
4 = großer Manatrank
5 = kleiner Dolch
... und so weiter. Wenn wir bei dem bleiben, was wir bisher wissen, sähe das Inventar z.B. so aus:

int platz1 = 1; //auf Platz 1 liegt ein kleiner Heiltrank
int platz2 = 5; //auf Platz 2 liegt ein kleiner Dolch
int platz3 = 0; //auf Platz 3 liegt nix

... und so weiter. Was sind eigentlich diese Schrägstriche ("//")? Ganz einfach: Wenn ihr zwei Schrägstriche hintereinander schreibt, wird alles was in derselben Zeile dahinter kommt vom Compiler ignoriert. Das heißt, ihr könnt euch auf diese Weise Notizen in euren Code schreiben. Macht davon ordentlich Gebrauch, um euch zu behalten was ihr noch nicht so gut kennt. (Sonst kann es sein, dass ihr die Datei zwei Wochen später öffnet und überhaupt nicht mehr wisst, was ihr da eigentlich geschrieben habt ;)
Kommentare könnt ihr auch über mehrere Zeilen schreiben. Dazu müsst ihr den Kommentar mit "/*" beginnen und mit "*/" abschließen. Aber zurück zum Thema: wenn wir für jeden Platz eine einzelne Variable anlegen, dauert das ganz schön lange für 16 * 8, also immerhin 128 Felder. Stellt euch vor ihr wollt das ganze ausgeben - dann müsst ihr alle 128 Variablen einzeln durchgehen. Das ist praktisch nicht machbar. Zum Glück gibt es eine Möglichkeit, das ganze Inventar in einer einzigen Variable abzulegen. Dies ist der (das?) so genannte Array. Ein Array ist eigentlich nichts anderes als eine Liste. Wenn ihr ein Array anlegt, müsst ihr angeben, wie viele Elemente in die Liste passen. Das Anlegen unserer Variable für das ganze Inventar klappt dann problemlos in einer Zeile, und zwar so:

int inventar[128];

Erst kommt der Datentyp der Listenelemente, in diesem Fall "int", dann die Kapazität des Arrays. Die Zahl in Klammern gibt also an, wieviele "int" - Variablen im Array gespeichert werden. Dabei hat sich das Array jetzt einfach eine bestimmte Menge Speicher gekrallt. Der speicher ist praktisch noch nicht verändert, also wissen wir nicht welche Werte jetzt gerade im Array liegen. Wenn wir alle Werte gleich zu Anfang auf 0 setzen wollen, gibt es eine spezielle Anweisung dafür - das ganze klappt aber nur bei der Deklaration, also nur wenn ihr das Array anlegt:


int inventar[128] = {};

Jetzt sind alle Elemente auf 0 gesetzt. Die geschweiften Klammern geben an, was das Array enthält. Wenn ihr bei der Deklaration Werte für einzelne Elemente angeben wollt, müsst ihr die Werte durch Kommas (Kommata) trennen. Es geht also alternativ auch so:

int inventar[128] = {1,2,3};

Jetzt haben wir das erste Element auf 3, das zweite auf 2 und das dritte auf 3 gesetzt. Alle anderen Elemente werden automatisch auf 0 gesetzt. Wir können jetzt auf die Elemente zugreifen, indem wir wieder die eckigen Klammern verwenden, um anzugeben welchen Platz im Array wir haben wollen.
Wir bekommen dann den Gegenstand (bzw. die Nummer des Gegenstandes) zu einem bestimmten Inventarplatz ausgegeben. Probierts mal aus, und guckt euch an welche Nummer ausgegeben wird wenn ihr das folgende Programm verwendet:

#include <iostream>

using namespace std;

int main(){
    int inventar[128] = {1, 2, 3};
    cout << inventar[2] << endl;

    cin.get();
    return 0;
}

Ganz klar... Nummer 3. Aber wieso 3? Wir haben doch die Nummer 2 an Platz 2 abgelegt! Das stimmt zwar, aber die Besonderheit liegt darin, dass wir gar nicht Platz 2 ausgegeben haben. Das Array beginnt nämlich bei der Nummerierung der Elemente mit 0 und nicht mit 1. Das heißt, inventar[0] wäre das 1. Element. Das 128. Element ist dann logischerweise inventar[127].
Vorsicht: Wenn ihr trotzdem auf das Element inventar[128] oder z.B. Inventar[129] zugreift, wird keine Fehlermeldung ausgegeben! Das Programm kontrolliert also nicht, ob ihr bei eurem Zugriff die Grenzen des Arrays einhaltet. Das kann zu ziemlich gemeinen Fehlern führen, denn ihr bekommt dann irgendeinen Wert von einer bestimmten Stelle im Speicher. Das ganze kann man sich in etwa so vorstellen wie unten auf dem Schaubild.


Das Array und verschiedene Zugriffe. Zugriffe über die Arraygrenzen sind möglich und deshalb tückisch.

Zugriffe können dabei sowohl lesend, wie im Beispiel oben, als auch schreibend stattfinden. Das ganze funktioniert über ganz normale Zuweisungen. Hier ein Beispiel, bei dem unser Held erst nichts trägt und dann einen Heiltrank aufnimmt:

#include <iostream>

using namespace std;

int main(){
    int inventar[128] = {};
    cout << "Inventarplatz 0: Gegenstand Nr." << inventar[0] << endl;
    //kleinen Heiltrank aufnehmen in Platz 0 des Inventars:
    inventar[0] = 1;
    cout << "Inventarplatz 0: Gegenstand Nr." << inventar[0] << endl;

    cin.get();
    return 0;
}

Wenn wir allerdings das ganze Inventar durchgehen möchten, z.B. um einen Gegenstand zu suchen oder alle Gegenstände nacheinander auszugeben, brauchen wir trotzdem noch eine Menge Zugriffe, die wir alle einzeln angeben müssen.
wir bräuchten also eine Methode, mit der wir das Inventar automatisch Schritt für Schritt durchlaufen könnten. Eine Möglichkeit ist die so genannte for - Schleife, die wir gleich noch kennen lernen werden.

3.5 Strukturen

Bevor wir auf die Schleifen zu sprechen kommen, hier noch zwei Konstrukte die man kennen sollte: Die so genannten Strukturen und das typedef - Schlüsselwort.
Strukturen sind eine Art eigener Datentyp, welcher mehrere Variablen speichert. So könnten wir z.B. aus unserem Held eine Struktur machen. Seine Daten wären dann z.B:
- Der Name (eine Zeichenkette)
- Die Charakterklasse (ein Buchstabe)
- Der Attacke - Wert (eine Zahl)
- Der Parade - Wert (eine Zahl)
- Das Inventar (ein Array von Zahlen)
- Der Goldvorrat (eine Kommazahl)
Wenn wir eine Struktur anlegen, die diese Elemente enthält, geht das ganz einfach. Wir schreiben das Schlüsselwort struct, dann den Namen der struktur und dann die Elemente in geschweiften Klammern. Das ganze beenden wir dann noch mit einem Semikolon. Beispiel:

#include <iostream>

using namespace std;

int main(){
    struct held {
      string name;
      char charakterklasse;
      int attacke;
      int parade;
      int inventar[128];
      float goldvorrat;
    };

    struct held held1;

    held1.name = "Hans";
    held1.attacke = 12;

    cout << held1.name << " hat den Attacke - Wert " << held1.attacke << endl;

    cin.get();
    return 0;
}

Dabei haben wir zuerst eine Struktur namens "held" definiert. Dann haben wir ein Exemplar dieser Struktur angelegt, mit der Zeile struct held held1. Das Exemplar hat den Titel "held1". Das "struct" in dieser Zeile kann man auch weglassen, aber es ist ganz nützlich, weil es einen daran erinnert, dass es sich um eine struktur handelt.
Wenn wir jetzt auf die Elemente der Struktur, auch "Members" genannt, zugreifen wollen, schreiben wir einen Punkt hinter den Namen der Struktur und dann die Bezeichnung der Member - variablen, z.B. "held1.name". So kann man auf die Membervariable "name" zugreifen und den Namen des Helden auslesen oder ändern. Genauso wurde das Ganze mit "attacke" gemacht. Die Ausgabeanweisung gibt uns die Werte einmal aus.
Der Vorteil dieser Strukturen? Ganz einfach: wenn wir mehr als einen Helden anlegen wollen, entfällt für jeden Helden das anlegen der nötigen Variablen für Attacke, Parade usw., statt dessen legen wir einfach eine neue Struktur an, die dann direkt die passenden Variablen enthält. Auch dazu ein Beispiel - so sähen die Deklarationen für zwei Helden ohne die held - Strukur aus:

string nameHeld1, nameHeld2;
char charakterklasseHeld1, charakterklasseHeld2;
int attackeHeld1, attackeHeld2;
int paradeHeld1, paradeHeld2;
int inventarHeld1[128], inventarHeld2[128];
float goldvorratHeld1, goldvorratHeld2;

...und so mit der "held" - Struktur:

struct held held1;
struct held held2;

3.6 Das typedef - Schlüsselwort

Das typedef - Schlüsselwort ist schnell erklärt. Es ermöglicht euch eigene Namen für bestimmte Datentypen. Wenn ihr z.B. die Deklaration

const unsigned int MAXIMALE_ERFAHRUNGSPUNKTE = 20000;

betrachtet, fällt auf, dass sie ganz schön lang ist. "const" steht dabei für "Konstante", also eine Variable die man im Programmverlauf nicht mehr ändern möchte (und dann auch nicht mehr ändern kann) - const - Variablen müssen ihren Wert direkt bei der Deklaration mitgegeben bekommen und werden typischerweise in Großbuchstaben geschrieben - so erkennt man, dass es sich um Konstanten handelt.
Um die lange Deklaration und andere dieser Art abzukürzen kann man das typedef - Schlüsselwort benutzen. Man schreibt "typedef", dann die Deklaration wie sie ist und dann wie man sie nennen möchte, z.B.:

typedef const unsigned int CUINT;

Jetzt können wir schreiben:

CUINT MAXIMALE_ERFAHRUNGSPUNKTE = 20000;
CUINT MAXIMALE_LEBENSPUNKTE = 360;

... und so weiter. Wenn ihr also irgendwo auf komische Datenypen stosst, die nicht zu C++ gehören, können sich dahinter umbenannte Standarddatentypen verbergen.

4. Kontrollstrukturen: Schleifen und Abfragen

4.1 Die for - Schleife

Nun also zu der oben schon erwähnten for - Schleife. Eine for - Schleife sieht etwa folgendermaßen aus:

for (int i = 0; i < 10; i++){
  //etwas tun...
}

Die Variable "i" wird beim Eintritt in die for - Schleife angelegt und gilt nur für die Dauer der Schleife, also innerhalb der geschweiften Klammern. "i" bekommt einen Startwert, dass geschieht bei der ersten Anweisung innerhalb der Schleife: "int i = 0;". (Dabei kann man für "i" jeden beliebigen Bezeichner wählen, aber üblicherweise heißt das Ding "i".) "i" ist die so genannte Laufvariable. Diese wird jetzt so lange verändert, wie die Bedingung der Schleife gilt. Die Bedingung steht an zweiter Stelle nach der Initialisierung der Laufvariablen, hier ist die Bedingung "i < 10" - das heißt, die Schleife wird so lange ausgeführt, wie "i" kleiner als 10 ist. Der dritte Teil in der Klammer, hier "i++", bestimmt wie die Laufvariable bei jedem Schritt verändert wird. In unserem Fall wird "i" bei jedem Schritt um 1 erhöht.
Dabei geht die Schleife so for: (sorry, das konnte ich mir nicht verkneifen;)

1. Initialisiere die Laufvariable!
2. Kontrolliere ob die Bedingung erfüllt ist!
    2.1 Wenn nein: verlasse die Schleife!
    2.2 Wenn ja:
        - führe die Anweisung(en) in den geschweiften Klammern aus!
        - verändere die Laufvariable!
        - kehre zu 2. zurück!

Schauen wir uns das ganze mal an einem Beispiel an. Diese Schleife gibt die Zahlen von 1 bis 10 in die Konsole aus:

for (int i = 1; i < 11; i++){
  cout << i << endl;
}

Probiert das ganze mal aus, und versucht vielleicht auch mal ein paar Varianten. (Mittlerweile dürfte hoffentlich klar sein, wie das Programm drumrum auszusehen hat: ihr schreibt die Schleife einfach in die "main" - Funktion - natürlich vor das "return 0", denn da ist die Funktion ja fertig!)
Oben hab ich immer geschrieben, dass die Laufvariable "verändert" wird, nicht "erhöht" - das hat den Grund, dass ihr frei entscheiden könnt, was mit der Variable bei jedem schritt gemacht werden soll. Guckt euch diese Beispiele an:

cout << "Schleife 1:" << endl;
for (int i = 10; i > 0; i--){
  cout << i << endl;
}

cout << "Schleife 2:" << endl;
for (int i = 0; i < 17; i += 2){
  cout << i << endl;
}

cout << "Schleife 3:" << endl;
for (int i = 32; i > 0; i /= 2){
  cout << i << endl;
}


Die for - Schleife ist sehr praktisch um Arrays auszugeben oder zu füllen. Beispiel:

int inventar[128];
for (int i = 0; i < 128; i++){
  inventar[i] = 1;
}

Jetzt haben wir das Array mit Einsen, also das ganze Inventar mit Heiltränken gefüllt. (Wieviel Sinn das macht ist eine andere Frage ;)
Um ein Array auszugeben kann die for - Schleife natürlich auch benutzt werden:

int inventar[128];
for (int i = 0; i < 128; i++){
  cout << inventar[i] << endl;
}

Jetzt bekommen wir mithilfe dieser wenigen Zeilen den Inhalt des kompletten Inventars ausgegeben.

4.2 Die while - Schleife

Außer der for - Schleife gibt es noch einen weiteren wichtigen Schleifentyp: die while - Schleife.
Dabei werden die Anweisungen in den geschweiften Klammern so lange wiederholt, wie die Bedingung in den Klammern hinter dem Schlüsselwort while gilt. Gilt diese nicht, wird die Schleife gar nicht erst ausgeführt. Beispiel:
int zahl = 0;
while (zahl < 11){
  zahl++;
  cout << zahl << endl;
}

Jetzt bekommen wir eine ähnliche Ausgabe wie schon bei den for - Beispielen: Die Zahlen von 1 bis 10.
Der Ablauf im Detail sieht so aus: zuerst wird "zahl" mit 0 initialisiert. Dann kommt die while - Schleife und prüft, ob die Bedingung ("zahl < 10") gilt. Weil das der Fall ist, werden nun die Anweisungen in der Schleife ausgeführt: "zahl" wird erhöht und danach ausgegeben. Jetzt springt das Programm wieder zur Bedingung und überprüft, ob noch ein weiterer Durchlauf stattfinden kann.
Stellt euch jetzt vor, die Variable würde statt 0 mit 11 initialisiert. Dann würde die Schleife nicht vom Programm betreten. Manchmal möchte mann aber, dass die Anweisungen in Klammern (auch "Schleifenrumpf" genannt) wenigstens ein Mal ausgeführt werden. Dafür gibts eine Variante der while - Schleife, die "do - while - Schleife". Beispiel:

int zahl = 11;
do {
  zahl++;
  cout << zahl << endl;
} while(zahl < 11);

Jetzt bekommen wir die 12 ausgegeben. Dann wird die Bedingung überprüft und festgestellt dass sie nicht gilt - daher werden die Anweisungen nicht noch einmal ausgeführt und es geht weiter im Programm.

4.3 Die if - Abfrage

Jetzt kommen wir zu einem wichtigen und sehr einfachen Element: der Abfrage. Die if - Abfrage prüft einfach nur eine Bedingung und führt, sollte die Bedingung erfüllt sein, die Anweisungen in den folgenden Klammern aus. Das ganze funktioniert also wie die while - Schleife, nur ohne Wiederholung.
Ein kurzes Beispiel:

if (attacke < 0){
  cout << "Attacke hat einen negativen Wert!" << endl;
}

Hier wird geprüft ob "attacke" kleiner als Null ist und gegebenenfalls eine Meldung ausgegeben. Bisher hatten wir nur die "<" (= "kleiner als") und die ">" (= "größer als") - Bedingung.
Hier andere mögliche Bedingungen: (mit a und b als "int" - variablen)

a &tl;= b Hier wird geprüft ob a kleiner oder gleich b ist.
a >= b Hier wird geprüft ob a größer oder gleich b ist.
a != b Hier wird geprüft ob a ungleich b ist.
a == b Hier wird geprüft ob a gleich b ist.

Das doppelte Gleichheitszeichen ist wichtig: wenn ihr hier ein einfaches Gleichheitszeichen setzt, findet eine Zuweisung statt.
Dabei müsste der Compiler dann doch eigentlich einen Fehler melden, oder? Schließlich ist eine Zuweisung keine Bedingung, und in den Klammern sollte doch ein Bedingung stehen! Wenn wir allerdings sowas hier schreiben...

if (attacke = 5){
  cout << "Blablabla" << endl;
}

..., bekommen wir keinen Compilerfehler, denn das Programm prüft hier wirklich eine Bedingung, nämlich die Variable "attacke". Dabei wird geprüft, ob "attacke" einen Wert ungleich Null hat. Das hängt mit den booleschen Variablen zusammen, die ja immer "true", also 1, oder "false", also 0 sein müssen - wenn man prüfen will, ob eine boolesche Variable gleich "true" ist, existiert für diesen Code

if (bedingung == true){

die Kurzschreibweise

if (bedingung){

, welche einfach prüft ob die boolesche Variable "bedingung" ungleich "false" und damit ungleich 0 ist. Genau das wird im Beispiel oben auch mit unserem "attacke" gemacht. Verwirrt? Dann probierts einfach mal aus! Merkt euch: bei Bedingungen prüft ein doppeltes Gleichheitszeichen, ob zwei Variablen den gleichen Wert haben.
Wichtig ist außerdem das Schlüsselwort "else" - hier wird an die if - Abfrage einfach ein zweiter Block angehängt, der nur dann ausgeführt wird, wenn die Bedingung hinter dem "if" nicht wahr ist. Ein Beispiel dazu:

if (attacke < 0){
  cout << "Attacke hat einen negativen Wert." << endl;
} else {
  cout << "Attacke hat einen positiven Wert oder ist Null." << endl;
}

Hinweis: Ihr könnt übrigens auch die geschweiften Klammern beim "if", "else", "for" oder "while" weglassen - unter einer Bedingung: es darf nur eine einzige Anweisung für das jeweilige Konstrukt folgen.
Das ist aber nicht ratsam wenn ihr Anfänger seid und noch das Gefühl habt, schnell den Überblick zu verlieren - insbesondere bei mehreren kombinierten "if ...else" - Anweisungen kann schnell unklar werden, zu welchem "if" das "else" dann gehört - der gefürchtete "dangling else" - Fehler.
Wichtig ist außerdem, dass ihr Bedingungen verknüpfen könnt. Dabei steht "&&" für ein "und" und "||" für ein "oder". Beispiel:

if (attacke > 0 || attacke == 0){
  cout << "Attacke hat einen positiven Wert oder ist Null." << endl;
}

(Natürlich kann man in diesem Fall auch direkt ">= 0" schreiben, aber es ist ja nur zur Demonstration ;) [top]

4.4 Die if - Abfrage (für Freaks)

Der Vollständigkeit halber hier noch eine freakige, extrem kompakte Form der if -Abfrage:

attacke = (attacke < 0) ? 0 : attacke;

Hier wird attacke ein Wert zugewiesen. Wenn die Bedingung in Klammern erfüllt ist, wird der Wert nach dem Fragezeichen zugewiesen, sonst der nach dem Doppelpunkt. Das heißt, in diesem Fall wir attacke auf 0 gesetzt, wenn die Variable einen negativen Wert enthält ( - ansonsten wird attacke = attacke gesetzt, es passiert also nichts). Das muss man nicht unbedingt auswendig können, aber man sieht es eben ab und zu.

5. Ein Übungsspiel

Hier also ein kleines Spiel, um das was wir bisher hatten auszuprobieren und zu üben. Damit das Spiel auch Eingaben entgegen nehmen kann, benötigt ihr die cin - Anweisung, die genau wie "cout" funktioniert - nur eben umgekehrt. Statt Daten auf den Ausgabestrom zu legen, werden sie vom Eingabestrom in Variablen gespeichert. Beispiel:

#include <iostream>

using namespace std;

int main(){
    string name;
    int alter;

    cout << "Wie heisst du?" << endl;
    cin >> name;
    cout << "Wie alt bist du?" << endl;
    cin >> alter;
    cout << "Du heisst " << name << " und bist " << alter << " Jahre alt." << endl;

    cin.ignore();
    cin.get();
    return 0;
}

Ich glaub ich brauche nicht mehr zu erklären was das Programm macht ;) Die Besonderheiten: Die ">" - Zeichen stehen bei "cin" genau andersrum als bei "cout". Ausserdem hab ich noch ein "cin.ignore" vor unserer "cin.get()" - Zeile zum Anhalten der Konsole eingebaut. Das hat den Grund, dass "cin" sich das letzte Enter - Zeichnen, welches eine Eingabe abschließt, merkt, es aber nicht ausgibt bzw. in unsere Variable schreibt. Dadurch liegt es noch im Puffer von "cin" und wird mit "cin.get()" gelesen - das Programm schließt sich dann sofort. Mit "cin.ignore" wird cin angewiesen, das nächste Zeichen im Puffer zu ignorieren und wartet dann bei "cin.get()" auf eine weitere Eingabe.

Hinweis: Es ist nicht so wichtig, sich zu merken warum dass jetzt so ist. Es können noch mehr Probleme auftreten, z.B. wenn ihr ein Leerzeichen in eurem Namen habt und diesen eingebt. Auch dazu gibts natürlich Lösungen, wie z.B. die "getline" - Anweisung, aber es lohnt sich nicht, sich unnötig lange mit Konsoleneingabe herumzuschlagen - wir wollen ja eigentlich Spiele mit grafischen Oberflächen programmieren, und die Konsoleneingabe braucht man da so gut wie nie.

Jetzt also zur Aufgabenstellung:
Es soll ein kleines Spiel programmiert werden, bei dem der Benutzer zuerst seinen Namen eingeben muss. Dann wird er begrüsst, und kann ein Ratespiel spielen. Dabei hat er 10 Versuche, eine Zahl zwischen 0 und 20 zu erraten, welche im Programmtext festgelegt ist.
Wenn er keine Lust mehr hat, gibt er einfach eine negative Zahl oder eine Zahl über 20 ein, und das Programm wird beendet. Wenn er eine gültige Zahl im Bereich zwischen 0 und 20 eingegeben hat, wird geschaut ob diese größer oder kleiner als die geheime Zahl ist, oder vielleicht sogar richtig geraten wurde. Wenn richtig geraten wurde, ist das Programm fertig und es erscheint eine Meldung, die den Spieler beglückwünscht. Ansonsten erscheint eine Meldung, welche angibt ob die eingegebene Zahl zu groß oder zu klein war, und es geht beim nächsten Versuch weiter. Wenn ihr möchtet, könnt ihr bei jedem Schritt die Anzahl der verbleibenden Versuche mit angeben.
Ihr braucht dabei z.B.:
- eine string - Variable für den Namen des Spielers
- drei int - Variablen: die geheime Zahl, die eingegebene Zahl und die Anzahl der (verbleibenden) Versuche
- eine boolesche Variable: wurde richtig geraten? (Eventuell: wurde abgebrochen?) - eine while - Schleife

Ich habe "z.B." geschrieben, weil es für den ein oder anderen Punkt auch andere Möglichkeiten gibt. Wenn ihr möchtet, schickt mir eure Lösung, dann baue ich sie eventuell in den nächsten Teil ein, wo wir uns ein paar Lösungsmöglichkeiten angucken werden.
So könnte das Programm in Aktion aussehen:



Ihr müsst dabei wissen, dass ihr die bisher erlernten Elemente auch ineinander verschachteln und so z.B. eine "if" - Abfrage innerhalb einer "while" - Schleife verwenden könnt.
Wenn euch das zu langweilig ist, hilft vielleicht noch eine Zusatzaufgabe, wenn das Spiel bis hier fertig ist: Wenn eine Zahl nicht erraten wurde, soll die richtige Zahl in einer Liste, die ausgegeben wird, markiert werden, etwa so:



So, ich wünsch euch viel Spaß, Erfolg und Geduld damit - bis zum nächsten Mal!

Dieses Tutorial wurde vom Isogames.de Mitglied Max_A_L geschrieben!