Live-Demo Initialisierung 1

#include <iostream>

using namespace std;

int main() {
    
    int i = 12;
    
    // keine ganze Zahl, daher wird abgeschnitten: j = 23
    int j = 23.5;
    
    cout << i << "," << j  << endl;
    
    // compiliert nicht, da 23.5 kein int ist
    // und Informationsverlust droht bei der Umwandlung
    // von double in int:
//    int j3 {23.5};
    
    return 0;
}

compiler

Beispiel '02-Initialisierung.cpp' (Ausschnitt 1)

Live-Demo Initialisierung 2

#include <iostream>

using namespace std;

int main() {
    int i = 12;
    // keine ganze Zahl, daher wird abgeschnitten: j = 23
    int j = 23.5;
    
    // k ist nicht initialisiert
    // k kann irgendeinen Wert haben
    int k;

    cout << i << "," << j  << "," << k << endl;
    
    // alternative Definition in einer Zeile:
    int i2 = 12, j2 = 23.5;
    
    // Vorsicht! i3 nicht initialisiert!
    int i3, j3 = 100;

    cout << i3 << "," << j3  << endl;
    
    return 0;
}

compiler

Beispiel '02-Initialisierung.cpp' (Ausschnitt 2)

Live-Demo Überlauf 1

#include <iostream>

using namespace std;

int main() {
    
    short m = 400, n = 100, k;
    k = m * n;
    
    cout << "k=" << k << endl;
    
    return 0;
}

compiler

Beispiel '02-Overflow.cpp (Ausschnitt 1)'

Live-Demo Überlauf 2

#include <iostream>

using namespace std;

int main() {
    // Hinweis: unsigned short m -> dann würde es passen
    
    m = 32767;
    cout << "m=" << m << endl;

    m = m + 1;
    cout << "m=" << m << endl;
    
    unsigned short us = 100;
    us = us - 101;

    cout << "us=" << us << endl;
        
    us = us + 1;
    cout << "us=" << us << endl;
    
    return 0;
}

compiler

Beispiel '02-Overflow.cpp (Ausschnitt 2)'

Live-Demo Typumwandlung

#include <iostream>

using namespace std;

int main() {

    // character vs. ASCII-Code
    char x = 98;
    cout << x << " <-> " << static_cast<int>(x) << endl;
    
    // 1023 kann von unsigned char nicht dargestellt werden
    unsigned char uc = 1023;
    // um den Zahlen-Wert von uc zu bekommen:
    int uci = uc;
    cout << "uci=" << uci << endl;
       
    return 0;
}

compiler

Beispiel '02-Umwandlung.cpp (Ausschnitt 1)'

Live-Demo Typumwandlung 2

#include <iostream>

using namespace std;

int main() {
    // besser:
    // compiliert nicht, da 1023 nicht durch unsigned char
    // dargestellt werden kann:
//    unsigned char uc2 {1023};

    // 1023 passt natürlich auch nicht in einen signed char,
    // da Initialisierung mit "=" compiliert das aber:
//    signed char sc = 1023;

    // gleiches Problem: -123 ist kein unsigned
//    unsigned int ui = -123;
//    cout << "ui=" << ui << endl;

    // das wuerde nicht compilieren:
//    unsigned int ui2 {-123};
    
    return 0;
}

compiler

Beispiel '02-Umwandlung.cpp (Ausschnitt 2)'

Live-Demo Limits

#include <iostream>
#include <limits>

using namespace std;

int main() {
    cout << "int: "
        << numeric_limits<int>::min() << " ... "
        << numeric_limits<int>::max() << endl;
    
    cout << "double: "
        << numeric_limits<double>::min() << " ... "
        << numeric_limits<double>::max() << endl;
    
    cout << "Anzahl Bytes von char: " << sizeof(char) << endl;
    cout << "Anzahl Bytes von int: " << sizeof(int) << endl;
    cout << "Anzahl Bytes von double: " << sizeof(double) << endl;
    
    
    int i = 10;
    cout << "sizeof(i)=" << sizeof(i) << endl;
    
    return 0; 
}

compiler

Beispiel '02-Limits.cpp'

Wissensspeicher 1

Ein Bezeichner …
- ist der Name einer Variablen
- folgt bestimmten Regeln, z. B. nur a-z, A-Z, 0-9 und _ sind erlaubt
- darf u.a. kein Schlüsselwort sein

Datentypen …
- haben Grenzen in Abhängigkeit von ihrer Größe: char vs. short vs. int vs. long (+ unsigned)
- laufen über, wenn die Grenzen überschritten werden (wrap around)
- können in einander umgewandelt werden. Achtung: mögl. Verlust von Informationen

Achtung bei Operationen mit mehreren Operanden unterschiedlicher Größer:

Compiler wandelt Typen ggf. um → potentieller Verlust von Informationen

Demo - Implizite Typumwandlung

#include <iostream>

using namespace std;

int main() {
    {   // A
        int a = 1024;
        short b = 256, c = 1025;

        short result = b + c * a;
        cout << "A: result = " << result << endl;
    }
    {   // B
        int a = 1, b = 256, c = 1024;

        int result = b + a / 2 * c;
        cout << "B: result = " << result << endl;
    }
    return 0; 
}

compiler

Beispiel zum Einfluss von implizieter Typumwandlung auf das Ergebnis bei Operationen mit mehreren Operanden

Demo - Genauigkeit Fließkommazahlen

#include <iostream>
#include <iomanip>
#include <limits>

using namespace std;

int main() {
    float f = 0.1;
    double d = 0.1;

    cout << std::setprecision(6);
    cout << "f = " << f << "\nd = " << d << endl;
    cout << std::setprecision(32);
    cout << "f = " << f << "\nd = " << d << endl;
    
    return 0; 
}

compiler

Beispiel zur Genauigkeit von Fließkommadatentypen

Live-Demo Bool

#include <iostream>

using namespace std;

int main() {
    int a = 100;
    int b = 20;
    
    if (a < b) cout << "kleiner" << endl;
    if (a > b) cout << "groesser" << endl;
    if (a == b) cout << "gleich" << endl;
       
    return 0;
}

compiler

Beispiel '02-Bool.cpp' (Ausschnitt 1)

Live-Demo Bool 2

#include <iostream>

using namespace std;

int main() {
    bool test = true;
    cout << "test=" << test << endl;
    
    test = 1;
    cout << "test=" << test << endl;
    
    // damit "true" und "false" ausgegeben wird, statt 1 und 0
    cout << boolalpha;
    cout << "test=" << test << endl;
     
    return 0;
}

compiler

Beispiel '02-Bool.cpp' (Ausschnitt 2)

Live-Demo Bool 3

#include <iostream>

using namespace std;

int main() {
    int a = 100, k = 123;
    
    bool c = k;
//    bool d {123}; // kompiliert nicht
    bool f = 0.1; // alles != 0 ist true

    cout << "c=" << c << ", f=" << f << endl;
    
    if (a) {
        cout << "a ist true" << endl;
        cout << "bla" << endl;
    }
    if (!a) cout << "a ist false" << endl;
     
    return 0;
}

compiler

Beispiel '02-Bool.cpp' (Ausschnitt 3)

Live-Demo Felder 1

#include <iostream>

using namespace std;

int main() {
    int feld[5] = {1,2,3,4,5};
    
    cout << feld[0] << "," << feld[1] << "," << feld[2] << "," << feld[3] << "," << feld[4] << endl;

    // Zuweisung an Feld-Element
    feld[0] = 11;
    // Ausgabe von Feld-Element
    cout << feld[0] << endl;

    // Vorsicht! Bereichs-Überschreitung
    cout << feld[5] << endl;
    cout << feld[50000000] << endl;

    return 0;
}

compiler

Beispiel '02-Array.cpp' (Ausschnitt 1)

Live-Demo Felder 2

#include <iostream>

using namespace std;

int main() {
    int a = 5;
    int b[a];

    for (int i = 0; i < a; i++) {
        b[i] = i * i;
    }
    
    for (int i = 0; i < a; i++) {
        cout << "b[" << i << "] = " << b[i] << endl;
    }

    return 0;
}

compiler

Beispiel '02-Array.cpp' (Ausschnitt 2 mit -pedantic)

Live-Demo Felder 3

#include <iostream>

using namespace std;

int main() {
    int a = 5;
    int b[a];

    for (int i = 0; i < a; i++) {
        b[i] = i * i;
    }
    
    for (int i = 0; i < a; i++) {
        cout << "b[" << i << "] = " << b[i] << endl;
    }

    return 0;
}

compiler

Beispiel '02-Array.cpp' (Ausschnitt 2 ohne -pedantic)

Live-Demo Vector 1

#include <iostream>
#include <vector>

using namespace std;

int main() {
    vector<int> v = {2,3,6,8};
    
    // Zugriff wie beim Array
    cout << v[0] << "," << v[1] << endl;
    v[2] = 5;
    // Größe
    cout << "|v|=" << v.size() << endl;
    
    // Einfügen
    v.push_back(13);
    cout << "|v|=" << v.size() << endl;

    return 0;
}

compiler

Beispiel '02-Vector.cpp' (Ausschnitt 1)

Live-Demo Vector 2

#include <iostream>
#include <vector>

using namespace std;

int main() {
    vector<int> v = {2,3,6,8}; 
    cout << v[0] << ","
         << v[1] << ","
         << v[2] << ","
         << v[3] << endl;
        
    // Vorsicht: Bereichsueberschreitung
    cout << v[10] << endl;

    // mit v.at(10) greift man auch auf das 10.
    // schmeißt ggf. Exception (Kapitel 12)
    cout << v.at(10) << endl;

    return 0;
}

compiler

Beispiel '02-Vector.cpp' (Ausschnitt 2)

Live-Demo String

#include <iostream>

using namespace std;

int main() {
    string s {"Tortmund"};
    s[0] = 'D';

    string s2 = "TU";
    
    string s3 = s;
    s3 += "-Barop";
    
    cout << s << endl << s2 << endl << s3
        << endl << s.length() << endl;  

    return 0;
}

compiler

Beispiel '02-String.cpp'

Live-Demo Struct

#include <iostream>

using namespace std;

struct UnserDatentyp {
    char name[40];
    unsigned int matrikel;
    bool eidp;
};  

int main() {
    UnserDatentyp student = {"Hugo Hase", 44221, true};
    UnserDatentyp studenten[50000];

    unsigned int mnr = student.matrikel;
    cout << student.name << " " << mnr << endl;

    return 0;
}

compiler

Beispiel '02-String.cpp'

Wissensspeicher 2

Bool’sche Ausdrücke

oft genutzt zur Beeinflussung des Kontrollflusses
Dualismus aus C: != 0 → true, == 0 → false

Zusammengesetzte Datentypen

Arrays
- gleicher Datentyp liegt n-mal vor
- C++-Alternative: Vector

Zeichenketten
- In C ein Array von char; immer mit Nullterminierung
- C++-Alternative: String

Datenverbund (struct)
- Komposition von mehreren Datentypen zu einem neuen Datentyp
- Zusammenfassen von Informationen, die semantisch zusammenhängen, z. B. ein(e) Student:in
- Zugriff auf einzelne Elemente über Punktoperator: studierende.name

Live-Demo enum

#include <iostream>

using namespace std;

enum Farbe { rot, gruen, blau, gelb };

int main() {
    Farbe f = rot;
    cout << "Farbe f = " << f << endl;

    f = static_cast<Farbe>(2); 
    cout << "Farbe f = " << f << endl;

    if (f == 2) {
        cout << "blau" << endl;
    }
    return 0;
}

compiler

Beispiel '02-Enum.cpp'