Wissensspeicher 5

Alt

Zeiger (oder das Tor zur Hölle 😈) - int *k = 0x4711;
Zeiger sind …
- selbst Variablen deren Größe sich nach der Architektur richtet; nicht nach dem Datentyp auf den sie zeigen
- können beliebige Adressen enthalten und greifen dort auf Speicher zu 🚨
- veränderbar: siehe Zeigerarithmetik

Neu

Dynamische Speicherverwaltung
- Zur Laufzeit Speicher beliebiger Größe anfordern
- Betriebssystem liefert Zeiger auf den Anfang des Bereichs
- Wichtig: Für jede Allokation muss es genau eine Freigabe geben
- Operationen: new/new[] und delete/delete[]

Live-Demo - Speicherlayout

#include <iostream>
#include <iomanip>
using namespace std;

int main() {
    constexpr int len = 10;
	int statArr[len] = {0};
	int *dynArr = NULL;

	cout << "Stack" << endl;
	cout << "----------" << endl;
	for (int i = len - 1; i >= 0; i--) {
		cout << "&statArr[" << setfill('0') << setw(3) << dec << i << "] = " << hex << &statArr[i] << endl;
	}
	cout << "----------" << endl;

	dynArr = new int[len];
	cout << "Heap" << endl;
	cout << "----------" << endl;
	for (int i = len - 1; i >= 0; i--) {
		cout << " &dynArr[" << setfill('0') << setw(3) << dec << i << "] = " << hex << &dynArr[i] << endl;
	}
	cout << "----------" << endl;
	delete[] dynArr;
}

compiler

Zeiger-Zeiger - Live-Demo

#include <iostream>
#include <iomanip>
using namespace std;

static void gebeArrayAus(int *arr, int n) {
	cout << "----------" << endl;
	for (int i = 0; i < n; i++) {
		cout << "statArr[" << setfill('0') << setw(3) << i << "] = " << setfill(' ') << setw(3) << dec << arr[i];
		cout << ", &statArr[" << setfill('0') << setw(3) << dec << i << "] = " << hex << &arr[i] << endl;
	}
	cout << "----------" << endl;
}

int main(void) {
	constexpr int len = 10;
	int statArr[len] = {0};

	int *pStatArr = NULL;
	int **ppStatArr = NULL;

	gebeArrayAus(statArr, len);

	pStatArr = &statArr[3];
	ppStatArr = &pStatArr;
	**ppStatArr = 21;

	cout << "\n   pStatArr = &statArr[3];" << endl;
	cout << "  ppStatArr = &pStatArr;" << endl;
	cout << "**ppStatArr = 21;" << endl;
	cout << "&pStatArr = " << hex << &pStatArr << ",   pStatArr = " << hex << *ppStatArr << ",   *pStatArr = " << dec << **ppStatArr << endl;
	cout << "ppStatArr = " << hex << ppStatArr << ", *ppStatArr = " << hex << *ppStatArr << ", **ppStatArr = " << dec << **ppStatArr  << endl;
	cout << "\n----------\n" << endl;

	*ppStatArr = *ppStatArr + 4;
	**ppStatArr = 42;
	cout << " *ppStatArr = *ppStatArr + 4;" << endl;
	cout << "**ppStatArr = 42;" << endl;
	cout << "&pStatArr = " << hex << &pStatArr << ",   pStatArr = " << hex << *ppStatArr << ",   *pStatArr = " << dec << **ppStatArr << endl;
	cout << "ppStatArr = " << hex << ppStatArr << ", *ppStatArr = " << hex << *ppStatArr << ", **ppStatArr = " << dec << **ppStatArr << "\n" << endl;
	
	gebeArrayAus(statArr, len);

	return 0;
}

compiler

Zeiger-Zeiger - Erklärung

constexpr int len = 10;
int statArr[len] = {0};

int *pStatArr = NULL;
int **ppStatArr = NULL;

Zeiger-Zeiger - Erklärung

constexpr int len = 10;
int statArr[len] = {0};

int *pStatArr = NULL;
int **ppStatArr = NULL;

pStatArr = &statArr[3];

Zeiger-Zeiger - Erklärung

constexpr int len = 10;
int statArr[len] = {0};

int *pStatArr = NULL;
int **ppStatArr = NULL;

pStatArr = &statArr[3];
ppStatArr = &pStatArr;

Zeiger-Zeiger - Erklärung

constexpr int len = 10;
int statArr[len] = {0};

int *pStatArr = NULL;
int **ppStatArr = NULL;

pStatArr = &statArr[3];
ppStatArr = &pStatArr;
**ppStatArr = 21;

Zeiger-Zeiger - Erklärung

constexpr int len = 10;
int statArr[len] = {0};

int *pStatArr = NULL;
int **ppStatArr = NULL;

pStatArr = &statArr[3];
ppStatArr = &pStatArr;
**ppStatArr = 21;

*ppStatArr = *ppStatArr + 4;
**ppStatArr = 42;

Zeiger-Zeiger - Erklärung

constexpr int len = 10;
int statArr[len] = {0};

int *pStatArr = NULL;
int **ppStatArr = NULL;

pStatArr = &statArr[3];
ppStatArr = &pStatArr;
**ppStatArr = 21;

*ppStatArr = *ppStatArr + 4;
**ppStatArr = 42;

Live-Demo - Funktionen

#include <iostream>

using namespace std;

void zeichne_10_sterne();

int main(void) {
    zeichne_10_sterne();
    zeichne_10_sterne();
    zeichne_10_sterne();

	return 0;
}

void zeichne_10_sterne() {
    int k = 10;
    while (k--){
        cout << '*';
    }
    cout << endl;
}

compiler

Live-Demo - Funktionen mit Parameter

#include <iostream>

using namespace std;

void zeichne_sterne(int k) {
    while (k--) std::cout << '*';
    std::cout << std::endl;
}

void zeichne_10_sterne() {
   zeichne_sterne(10); 
}

int main(void) {
    zeichne_sterne(10);
    zeichne_10_sterne();

	return 0;
}

compiler

Live-Demo - Funktionen mit mehreren Parametern

#include <iostream>

using namespace std;

void zeichnen(int k, char c){
    // zeichne k mal das Zeichen c
    while (k--) std::cout << c;
    std::cout << std::endl;
}

int main(void) {
    for (int i = 0; i < 26; ++i){
        zeichnen(i+1, 'A'+i);
    }

	return 0;
}

compiler

Live-Demo - Parameterübergabe 1

#include <iostream>

using namespace std;

void tausche_wert(int a, int b) {
    int h = a;
    a = b;
    b = h;
    cout << "Fkt.: " << a << " " << b << endl;
}

int main(void) {
    int a = 3, b = 11;
    cout << "main: " << a << " " << b << endl;
    tausche_wert(a, b);
    cout << "main: " << a << " " << b << endl;

	return 0;
}

compiler

Live-Demo - Parameterübergabe als Zeiger

#include <iostream>

using namespace std;

void tausche_wert(int *pa, int *pb) {
    int h = *pa;
    *pa = *pb;
    *pb = h;
    cout << "Fkt.: " << *pa << " " << *pb << endl;
}

int main(void) {
    int a = 3, b = 11;
    cout << "main: " << a << " " << b << endl;
    tausche_wert(&a, &b);
    cout << "main: " << a << " " << b << endl;

	return 0;
}

compiler

Feedback erwünscht

Bitte meldet Euch rechtzeitig, nicht erst mit der Evaluation gegen Ende des Semesters
Via E-Mail an eidp-problems@ls12.cs.uni-dortmund.de
Via Kummerkasten auf der Webseite sys.cs.tu-dortmund.de/de/kummerkasten – auch anonym möglich!
Persönlich nach der Vorlesung oder schaut vorbei

Wissensspeicher 6

Funktionen
- Kapselung von wiederkehrenden Abläufen
- Erhöht Lesbarkeit und Wartbarkeit

Varianten
- ohne Parameter(n) und ohne Rückgabewert → ?
- mit Parameter(n) und ohne Rückgabewert → setprecision(int n)
- mit Parameter(n) und mit Rückgabewert → double sin(double x)
- ohne Parameter(n) und mit Rückgabewert → int rand(void)

Übergabe von Parametern und Rückgabewerten als Kopie auf dem Stack (→ Call by value)
Übergabe von modifizierbaren Parametern mittels Zeigern (→ Call by reference)

Technisch immer noch Call by value, aber jetzt werden die Adressen kopiert.

Live-Demo - Parameterübergabe als Referenzen

#include <iostream>

using namespace std;

void tausche_wert(int &a, int &b) {
    int h = a;
    a = b;
    b = h;
    cout << "Fkt.: " << a << " " << b << endl;
}

int main(void) {
    int a = 3, b = 11;
    cout << "main: " << a << " " << b << endl;
    tausche_wert(a, b);
    cout << "main: " << a << " " << b << endl;

	return 0;
}

compiler

Live-Demo - Übergabe von Arrays

#include <iostream>

using namespace std;

void inkrement(int b[5]) {
    for (int k = 0; k < 5; k++) {
        b[k]++;
    }
    cout << "sizeof(b): " << sizeof(b) << endl;
}

int main(void) {
    int i, a[5] = {2, 4, 6, 8, 10};
    cout << "sizeof(a): " << sizeof(a) << endl;
    inkrement(a);
    for (int k = 0; k < 5; k++) {
        cout << a[k] << " ";
    }
    cout << endl;

	return 0;
}

compiler

Live-Demo - Übergabe von Arrays mit Bereichsgrenzen

#include <iostream>

using namespace std;

void inkrement(int b[], int const n) {
    for (int k = 0; k < n; k++) {
        b[k]++;
    }
}

int main(void) {
    int constexpr n = 5;
    int i, a[n] = {2, 4, 6, 8, 10};

    inkrement(a, n);
    for (int k = 0; k < n; k++) {
        cout << a[k] << " ";
    }
    cout << endl;

	return 0;
}

compiler

Live-Demo - Übergabe eines Vektors

#include <iostream>
#include <vector>

using namespace std;

void plusEinsAusgabe(vector<int> v) {
    for (int i = 0; i < v.size(); i++) {
        v[i]++;
        cout << v[i] << " ";
    }
    cout << endl;
}

int main(void) {
    vector<int> vec = {1,2,3,4,5};
    plusEinsAusgabe(vec);
    for (int i: vec) {
        cout << i << " ";
    }
    cout << endl;

	return 0;
}

compiler

Live-Demo - Funktionen mit Schablonen

#include <iostream>

using namespace std;

template <typename T>
T arrayMin(int const n, T a[]) {
    if (n == 0)
        return -1;
    T min = a[0];
    for (int i = 1; i < n; ++i) {
        if (a[i] < min) {
            min = a[i];
        }
    }
    return min;
}

int main() {
    double feld[] = {10.1, 9.9, 9.3, 10.5, 11.3, 12.0};
    short feld2[] = {10, 9, 3, 5, 11, 12};

    double min = arrayMin<double>(6, feld);
    short min2 = arrayMin<short>(6, feld2);

    cout << "double minimum: " << min << endl;
    cout << "short minimum: " << min2 << endl;
    return 0;
}

compiler

Live-Demo - Schablonentyp automatisch ableiten

#include <iostream>

using namespace std;

template<typename T> T func(T a) {
    T result = a * 2;
    return result;
}

int main() {
    short s = func<short>(1024);
    float f = func<float>(1024);
    int   i = func<int>(1024);

    cout << "s = " << s << endl;
    cout << "f = " << f << endl;
    cout << "i = " << i << endl;

    return 0;
}

compiler

Wissensspeicher 7

Bisher: Zeiger verweisen auf beliebige Adressen

Jetzt: Referenzen
- Ist wie ein Alias auf eine Variable zu sehen
- Erlaubt Zugriff auf denselben Speicher wie bei einer Variablen
- Kann den Inhalt verändern
- Alias wird bei der Initialisierung einmal festgelegt

Funktionsschablonen (function templates)
- Deklaration mit template <typename T> T foo(T in);
- Funktion einmal implementieren
- Codegenerierung für verschiedene Datentypen

Live-Demo - zweidimensoniale Arrays im Speicher

#include <iostream>

using namespace std;

int main(void) {
    constexpr int rows = 3, columns = 4;
    int arr[rows][columns] = {0};

    cout << "Größe einer Zeile: " << sizeof(arr[0]) << endl;
    cout << "Abstand zw. Zeile 1 und 2: ";
    cout << (reinterpret_cast<intptr_t>(&arr[2]) - reinterpret_cast<intptr_t>(&arr[1])) << endl;

	return 0;
}

compiler

Live-Demo - Uhrzeit

#include <iostream>
#include <ctime>

using namespace std;

int main(void) {
    time_t jetzt = time(nullptr);
    cout << jetzt << endl;

    struct tm *jetzt_lokal = localtime(&jetzt);
    char *uhrzeit = asctime(jetzt_lokal);
    cout << uhrzeit << endl;

	return 0;
}

compiler

Live-Demo - Zeitmessung

#include <iostream>
#include <chrono>

using namespace std;
using namespace std::chrono;

int main(void) {
    time_point<steady_clock> jetzt = steady_clock::now();
    for (int i = 0; i < 10000000; i++) {}
    time_point<steady_clock> spaeter = steady_clock::now();

    duration<double> zeit = spaeter - jetzt;
    cout << "Zeit: " << zeit.count() << " sec." << endl;

	return 0;
}

compiler

Live-Demo - Makros

#include <iostream>

using namespace std;

#define SQUARE(x) ((x) * (x))
#define PFERD 2

int hallo(void) {
    cout << "hallo" << endl;
    return 1;
}

int main(void) {
    int x = 2;
    cout << SQUARE(++x) << endl;
    x = 2;
    cout << SQUARE(x++) << endl;

    SQUARE(hallo());

#ifdef PFERD
    cout << "PFERD!" << endl;
#endif
#if PFERD == 1
    cout << "Ein Pferd" << endl;
#endif

	return 0;
}

compiler

Wissensspeicher 8

Standardbibliotheken
- Stellen häufig genutzte Funktionen bereit → sin() oder time()
- Alte C-Bibliotheken nutzbar über vorangestelltes c: #include <cmath>

inline-Funktionen
- Bsp.: inline int foo(void);
- Ersetzt jeden Aufruf durch die Anweisung in der Funktion
- Nur ein Hinweis an den Compiler

Makros
- Werden durch den C++-Präprozessor ausgewertet („reine Textersetzung, außer bei Strings“)
- Wird in C oft für die Dimensionierung von Arrays genutzt: #define MAX_ARR_SIZE 100
- Achtung: Markos können versteckte Seiteneffekte haben

Beispiel - Makros 1

// ...
#define SQUARE(x) ((x) * (x))

int main(void) {
    int x = 2;
    cout << SQUARE(++x) << endl;

    return 0;
}

Erwartete Ausgabe: 12
Festgestellte Ausgabe: 16

Auswertungsreihenfolge der Erhöhung ist undefiniert
Nur die Auswertungsreihenfolge der Multiplikation ist definiert

Quelle: cppreference.com, Abschnitt „Evaluation Order“

Beispiel - Makros 2

#include <cstdio>
 
int a() { return std::puts("a"); }
int b() { return std::puts("b"); }
int c() { return std::puts("c"); }
 
void z(int, int, int) {}
 
int main()
{
    z(a(), b(), c());       // all 6 permutations of output are allowed
    return a() + b() + c(); // all 6 permutations of output are allowed
}

Undefined behavior

1) If a side effect on a memory location is unsequenced relative to another side effect on the same memory location, the behavior is undefined. 
i = ++i + 2;       // well-defined
i = i++ + 2;       // undefined behavior until C++17

Quelle des Beispiels und des Ausschnitts: cppreference.com, Abschnitt „Evaluation Order“ (CC-BY-SA)