| ### 3. Abend
| Ziele : Wir sind nach diesem Abend in der Lage Variablen von verschiedenen Datentypen zu definieren. Wir wissen ab heute was gültige Variablennamen sind.
### Variablen definieren
| Lasst uns einfach zum Spass ein paar Variablen von verschiedenen Datentypen definieren und die Eigenschaften der Datentypen betrachten.
| ### bool
| Eine Variable vom Datentyp bool kann nur zwei verschiedene Werte annehmen : true (wahr) oder false (falsch)
bool.cpp |
    // Für Ein- und Ausgaben
    #include <iostream>

    using namespace std;

    // Hier unsere grossartige
    // main - Funktion
    int main()
    {
        bool DieWahrheit = true;
        cout << DieWahrheit << endl;
        DieWahrheit = false;
        cout << DieWahrheit << endl;

        // Speicher, den eine
        // bool Variable braucht
        cout << sizeof(bool) << endl;

        // Ein Vergleich ist
        // ein bool'scher
        // Ausdruck !
        bool test = (4 != 5);
        test = (6 == 7);

        return 0;
    }
| Ein boole'scher Ausdruck ist ein Ausdruck der entweder falsch oder wahr ist. Häufig ist das ein Vergleich. Hier einige Beispiele für boole'sche Ausdrücke:
| - 4 > 3 ist wahr - 3 == 3 ist wahr - 3 == 4 ist falsch - 6 < 3 ist falsch etc.
### short, int und long
| Diese Datentypen sind zuständig für ganze Zahlen. Sie unterscheiden sich nur im Speicherplatz den sie brauchen. Ein short braucht 2 Bytes (16 Bit) und hat somit den kleinsten Zahlenbereich dieser drei Datentypen. Der int ist besonders, da sein Wertebereich nicht festgelegt ist. Mit dem 32-Bit Windows Compiler ist er 32 Bit (=4 Byte). Der long Datentyp ist immer 4 Byte gross.
shortintlong.cpp |
    // Für Ein- und Ausgaben
    #include <iostream>
    // Für Grenzen der
    // Datentypen
    #include <iostream>

    using namespace std;

    // Hier unsere grossartige
    // main - Funktion
    int main()
    {
        short minShort = SHRT_MIN;
        short maxShort = SHRT_MAX;
        cout << minShort << endl;
        cout << maxShort << endl;
        cout << sizeof(short) << endl;

        int minInt = INT_MIN;
        int maxInt = INT_MAX;
        cout << minInt << endl;
        cout << maxInt << endl;
        cout << sizeof(int) << endl;

        long minLong = LONG_MIN;
        long maxLong = LONG_MAX;
        cout << minLong << endl;
        cout << maxLong << endl;
        cout << sizeof(long) << endl;

        return 0;
    }
### char
| Der Datentyp char ist im Grunde genommen ein normaler Datentyp für Ganzzahlen wie short oder int. Ein char kann dabei nur 8 Bit gross sein, das heisst sein Zahlenbereich erstreckt sich von -128 bis 127. Der char Datentyp wird meistens zum Speichern von Zeichencodes. Als Zeichencode wird meistens der ASCII-Code verwendet (siehe auch Buch s. 827). Verwendet man im Programm ein einzelnes Zeichen in Anführungsstrichen 'A', ersetzt der Compiler dieses Zeichen mit dem entsprechenden ASCII-Wert ('A' = 65). Es ist also gleichwertig zu schreiben :
    char einZeichen = 65;
oder
    char einZeichen = 'A';
| Man kann somit auch mit Buchstaben rechnen !
| Die Ausgabe von char über cout gibt aber nicht den Wert der Variable aus (beim Beispiel also nicht 65) sondern das Zeichen mit diesem Code (also A).
char.cpp |
    // Für Ein- und Ausgaben
    #include <iostream>
    // Für Grenzen der
    // Datentypen
    #include <limits>

    using namespace std;

    // Hier unsere grossartige
    // main - Funktion
    int main()
    {
        char minChar = CHAR_MIN;
        char maxChar = CHAR_MAX;
        cout << minChar << endl;
        cout << maxChar << endl;
        cout << sizeof(char) << endl;

        char einZeichen = 'A';
        einZeichen = 65;

        cout << einZeichen << endl;

        char test = 'B'- 'A';

        return 0;
    }
### signed und unsigned Modifizierer
| Ein Modifizierer ist ein Schlüsselwort, das falls es vor dem Datentypen einer Variablendefinition steht die Variable entsprechend modifiziert. Der signed-Modifizierer bewirkt, dass eine Variable vom Datentypen char, short, int und long (Ganzzahltypen) als Variable mit Vorzeichen behandelt wird. Der Compiler geht bei Variablendefinitionen automatisch von Vorzeichenbehafteten Datentypen aus, so dass es nicht nötig ist, explizit signed vor eine Variabledefinitionen zu schreiben. Will man aber eine Variable nur als positive Ganzzahl verwenden, ist es nötig dies dem Compiler mittels des unsigned-Modifizierers mitzuteilen.
unsigned.cpp |
    // Hier unsere grossartige
    // main - Funktion
    int main()
    {
        signed char x = -33;
        // gleich wie
        char y = -33;

        int i = -55;
        unsigned int n = 0;

        return 0;
    }
### float, double und long double
| Zahlen, die nach dem Komma Stellen besitzen werden in C++ mit einem Punkt dargestellt : 3.55 Der Compiler interpretiert ein Komma anders, als wir es uns gewohnt sind ! Solche Zahlen werden Gleitpunktzahlen genannt. Die Datentypen float, double und long double unterscheiden sich in der Grösse des Speicherplatzes und dadurch auch in der Genauigkeit.
floatdouble.cpp |
    #include <iostream>

    #include <limits>

    using namespace std;

    int main()
    {
        float minFloat = FLT_MIN;
        float maxFloat = FLT_MAX;
        cout << minFloat << endl;
        cout << maxFloat << endl;
        cout << sizeof(float) << endl;

        double minDouble = DBL_MIN;
        double maxDouble = DBL_MAX;
        cout << minDouble << endl;
        cout << maxDouble << endl;
        cout << sizeof(double) << endl;

        long double minLongDouble = LDBL_MIN;
        long double maxLongDouble = LDBL_MAX;
        cout << minLongDouble << endl;
        cout << maxLongDouble << endl;
        cout << sizeof(long double) << endl;

        return 0;
    }
| Für diese Gleitpunktzahlen existiert kein signed/unsigned-Modifizierer.
### const
| Soll eine Variable während des Programmlaufes nicht mehr verändert werden können, definieren wir sie als konstant mit dem Schlüsselwort const ! Der Compiler verhindert, dass der Variable ein Wert zugewiesen werden kann. Der einzige Zeitpunkt in der eine const Variable einen Wert erhalten darf ist bei der Initialisierung !
    int main()
    {
        const double pi = 3.1415;

        return 0;
    }
| Das heisst, dass folgendes kleine Programm nicht mehr kompiliert wird !
    int main()
    {
        const double pi = 3.1415;

        pi = 2.14;  // Fehler !

        return 0;
    }