• Wiederholung zum Kontrollfluss,
• Funktionen (Deklaration und Definition), Overloading
• Einführung von strukturierten Datentypen
• Pointer und Referenzen (sowie Arrays) und einführend etwas zum Handling des Memory in C++ und C

• C++ übernimmt aus C die bekannten Basisdatentypen:
  • Für ganze Zahlen (Integer-Typen): char, short, int, long, long long, Bsp.: int i = 42;
  • Für Gleitkommazahlen: float, double, long double, Beispiel: double d = 42.23;
  • Für Buchstaben: char, Beispiel: char c = ’a’;
  • Wahrheiswerte (in C++ Teil der Sprache): bool, Beispiel: bool b = true;
• Achtung: Auch in C++ ist die Größe der Basisdatentypen systemabhängig!
• C++ bietet zusätzlich eine Klasse für Strings im Header <string> an.

• Variablen können entweder deklariert (int i;) oder direkt mit einem Wert initialisiert werden (int i = 42; float f = randomFloat();).
• Werden Variablen direkt initialisiert, kann in C++ anstelle des Datentyps das Schlüsselwort auto verwendet werden:
  • auto i = 42; auto f = randomFloat();
• Der Compiler ermittelt den Datentyp dann automatisch (Type Inference).

Beim Übersetzen in ein ausführbares Programm werden folgende Schritte durchgeführt:

1. Der Präprozessor ersetzt Makros (z. B. #include).
2. Der Compiler übersetzt den Quellcode in ein Assemblerprogramm.
3. Der Assembler erzeugt Maschinencode.
4. Der Linker verbindet die vers. Dateien zu einer ausführbaren Datei.

In C++ gibt es verschiedene Cast-Operatoren mit abgestufter Wirkungsweise:

• static_cast = Operator erlaubt Konvertierungen zwischen Basisdatentypen sowie zwischen Klassen, die durch öffentliche, nicht-virtuelle Ableitung auseinander hervorgehen.
• dynamic_cast = Hiermit werden Zeiger oder Referenzen auf miteinander verwandte polymorphe Klassen – und nur solche – konvertiert.
• const_cast = Dient ausschließlich dazu, die Konstantheit eines Typs zu entfernen. Dies ist ein schwerwiegender und potentiell fehlerträchtiger Vorgang.
• reinterpret_cast = Dieser Operator konvertiert beliebige Zeigertypen ineinander, unabhängig vom Verwandtschaftsgrad, und konvertiert alle Zeiger in ganzzahlige Typen und umgekehrt.

• Bedingung ist ein Ausdruck, der nach bool konvertierbar ist
• Anweisungen können Ausdrücke, Blöcke oder andere Kontrollstrukturen sein

Anweisung wird wiederholt ausgeführt, solange Bedingung zutrifft (also zu true ausgewertet wird).

Beispiel für while

int x = 0;
while (x<100) {
    std::cout << x++ << std::endl;
}

• Anweisung wird wiederholt ausgeführt, solange Bedingung true ist
• Anders als bei while wird hier Anweisung mindestens einmal ausgeführt

Beispiel für do-while

int x = 0;
do {
    std::cout << x++ << std::endl;
} while (x<100);

Der große Bruder der while-Schleife …

Die Anweisung break verursacht, dass der aktuelle (innerste) for, while oder case-Block verlassen wird.

#include <string>

int main(){
    std::string str;
    std::cin >> str;
    for(int i=0; true; ++i){
        if (!str[i]) 
        	break;
        str[i] = toupper(str[i]);
    }
}

• Verursacht einen Sprung an das Ende der aktuellen Schleife
• Nur innerhalb des Rumpfes von for, while und do-while-Schleifen
• Ermöglicht flachere und übersichtlichere Klammerstruktur

#include <string>
#include <iostream>

int main() {
    std::string str; std::cin >> str;
    for(int i=0; true; i++) {
        if (!str[i]) break;
        if (str[i]>=’A’ && str[i]<=’Z’) continue;
        if (str[i]>=’a’ && str[i]<=’z’) str[i] += (’A’−’a’);
    }
    std::cout << str << std::endl;
}

• Für Fallunterscheidungen

• Wichtig: Die einzelnen Anweisungsteile müssen explizit mit einem break-Statement beendet werden.
• Ansonsten werden alle folgenden Anweisungsteile mitausgeführt
• Sollten in der Anweisungsliste einer case Marke Variablen deklariert werden, so muss die Anweisungsliste in einem Block zusammengefasst werden (Grund: nicht klar definierbare Lebenszeit des Variablenbezeichners)

• Manchmal möchte man in Fallunterscheidung lokale Variablen anlegen
• Da break optional ist kann es hierzu zu Überspringen von Variablendeklarationen kommen!

switch(evt.getType()) {
    case PRESS_EVENT:
        int x = evt.x(); int y = evt.y();
        // ...
        break;
    case MOVE_EVENT:
        int x = evt.x(); int y = evt.y(); // geht nicht
        x = evt.x(); y = evt.y(); // geht auch nicht
        // ...
        break;
}

Lösung: lokale Blöcke benutzen

switch(evt.getType()) {
    case PRESS_EVENT:
    {
        int x = evt.x(); int y = evt.y();
        // ...
    }
    break;
    case MOVE_EVENT:
    {
        int x = evt.x(); int y = evt.y(); // geht!!
        // ...
    }
    break;
}

• C-Relikt
• wird in C++ sehr selten (und ungern) gesehen

int main() {
    int i = 0;
    for (; i<100; ++i){
        if (i == 10){
            goto MARKE;
        }
    }
    MARKE:
    std::cout << i << std::endl;
    return 0;
}

• Besser: Verwendung von Exceptions (später)

• MARKE und goto MARKE müssen in der gleichen Funktion stehen
• Andere Sprünge mittels setjmp und longjmp (verfügbar durch den Header <csetjmp>)
• Diese werden z.B. zur Fehlerbehandlung in C-Bibliotheken verwendet
• Sind aber gefährlicher
• In C++: Leichtere Ausnahmenbehandlung mittels try-catch-Blöcken und dem throw-Operator (später)

• Funktionen sind das Hauptelement zur Strukturierung eines Programms in C (und auch in C++ ein wichtiges Strukturierungselement).
• Funktionsdefinition ähnlich wie in Java:

int max( int a, int b )
{
	return a>b? a : b;
}

• Eine Funktion kann zunächst deklariert und später definiert werden.
• Beispiel: int max( int , int ); – hier dürfen die Namen der Parameter entfallen.

Warum gibt es die Unterscheidung zwischen Definition und Deklaration?

• Beim Übersetzten überprüft der Compiler bei jedem Funktionsaufruf:
  • Gibt es eine Funktion mit dem Namen?
  • Passen die angegeben Argumente mit den Typen der Parametern zusammen?
  • Passt der Rückgabetyp?
• Dazu reichen dem Compiler die Informationen aus der Deklaration aus.

Eine Besonderheit in C im Vergleich zu anderen C-ähnlichen Sprachen:

• Soll eine Funktion keine Parameter entgegennehmen ist es korrekter void als Parameterliste anzugeben.
• Das Fehlen einer Parameterliste in C bedeutet, dass eine beliebige Anzahl von Parametern mit beliebigen Typen übergeben werden kann (dies gilt nicht in C++):

int add_no_void () { int x = 5; int y = 2; return x + y; }

int add_with_void( void ) { int x = 5; int y = 2; return x + y; }

int main( void ) {
	int res1 = add_no_void (5, ’c’ ); // No error
	int res2 = add_with_void (5, ’c’ );// Error: too many arguments
}

• C++ bietet die Möglichkeit, für Funktionsparameter Standardausdrücke vorzugeben.
• Diese werden automatisch eingesetzt, wenn der entsprechende Parameter beim Aufruf fehlt.

int foo(int x, int y = 1000); 
int test = foo(42);

• Standardparameter müssen am Ende der Parameterliste stehen.
• Gibt es eine Funktionsdeklaration, so werden die Standardausdrücke dort angegeben und nicht in der Funktionsdefinition.

Funktionsparameter werden in C und C++ immer by value übergeben, d. h.:

• Die Parameter werden kopiert.
• Die Funktion arbeitet auf der Kopie eines Parameters.
• Das Original kann von der Funktion nicht verändert werden.

int foo(int i, int j) {
  i = i * 2;
  j++; // j = j + 1
  return i + j;
}

int main () {
  int i = 5; int j = 6; 
  int k = foo(i, j);
}

Was ist, wenn wir zwei Versionen einer Funktion für zwei verschiedene Typen haben wollen?

Beispiel: int-Division und double-Division

Im jupyter-book sind verschiedene Aufgaben angegeben:

Jupyter-Book Link

Hierüber kann dann direkt auf dem Hub eine Umgebung gestartet werden, in der C++ interpretiert wird (wird die ersten Termine genutzt):

JupyterHub Link

Vorgehensweise:

Ziel: Formales Modell, das von einer Maschine bearbeitbar ist.

Ziel: Maschinelle Verarbeitung von Informationen. Verarbeitung nur möglich auf Basis von Repräsentationen (Schwerpunkt Woche 2).

Ziel der Modellbildung: Lösung eines Problems.

Festlegen (durch Spezifikation), welches Ziel gelöst werden soll.

Präzisierung des Modells:

Methoden zur Modellbildung:

Logische Strukturen, Graphen, Grammatiken, Automatenmodelle, Petri-Netze, UML-Diagramme …

In fünf Schritten

1. Datenanalyse und -definition.
2. Signatur, Zweck und Funktionskopf angeben.
3. Beispiele erstellen.
4. Funktionsrumpf erstellen.
5. Funktionsweise überprüfen.

Durchführen von 1. Datenanalyse und Datendefinition: Überprüfen, ob die Aufgabenstellung die Verwendung von Strukturen nahe legt.

• Mit typedef kann direkt bei der Deklaration einer Struktur ein „einfacherer“ Name vereinbart werden:

typedef struct {
	char name [16];
	char lastname [16];
	unsigned int age;
} person_t;

person_t p = { "Vorname" , "Nachname" , 42};

Structs können innerhalb von Structs verwendet werden (wie Klassen in z.B. Java).

Die Größe eines Structs kann wie für primitive Datentypen abgefragt werden:

sizeof (struct person)
sizeof (person_t)

Aber: sizeof ( struct ) \(\neq\) Summe der Größe der einzelnen Bestandteile/ Member:

struct values {
	char c1;
	int i;
	char c2;
}

// Summ der Größe aller Member
// Output für 2 * sizeof ( char ) + sizeof ( int ) = 6
// Größe von struct values
// Output für sizeof ( struct values) = 12

Im jupyter-book sind verschiedene Aufgaben angegeben:

Jupyter-Book Link

Hierüber kann dann direkt auf dem Hub eine Umgebung gestartet werden, in der C++ interpretiert wird (wird die ersten Termine genutzt):

JupyterHub Link

Erinnerung: Eine Variable ist ein Name für eine Stelle im Speicher, an der ein Datum abgespeichert wird.

• Zu jeder Variable existiert eine Adresse im Speicher.
• Diese Adresse kann man mit dem Adressoperator & erfahren:

int i = 5;
printf( _"%p"_ , &i ); // Ausgabe in C
// Mögliche Ausgabe: 0 x7ffcea219ff

• Ein Zeiger (engl. Pointer) enthält die Adresse einer Variable im Speicher.
• Die Speicheradresse einer Variable liefert der Adressoperator &.
• Spezielle Adresse: NULL – „Zeiger ins Nichts“.
• Die Variable zu einem Pointer liefert der Dereferenzierungsoperator *.
• Der Typ eines Pointers auf eine Variable vom Typ T ist T*.

int a = 42;
int* b = &a; // Adressoperator angewendet auf a
*b = 12; // Dereferenzierungsoperator angewendet auf b; a == 12

• Eine Array-Variable verhält sich wie ein Pointer, der auf das erste Element des Arrays zeigt.
• Auf einen Pointer kann – wie auf ein Array – mit dem []-Operator zugegriffen werden. Dabei gilt: ptr[i] == *(ptr+i)
• Übergibt man einen Array-Typ T[] als Parameter an eine Funktion, „verfällt“ der Typ zum entsprechenden Pointer T* (Array Decaying).

• Der Umgang mit Pointern ist besonders am Anfang schwierig.
• C++ führt mit Referenzen ein ähnliches Sprachmittel ein.
• Wie Pointer sind Referenzen Variablen, die Verweise auf andere Variablen speichern.
• Der Typ einer Referenz auf eine Variable vom Typ T ist T&.

Im jupyter-book sind verschiedene Aufgaben angegeben:

Jupyter-Book Link

Hierüber kann dann direkt auf dem Hub eine Umgebung gestartet werden, in der C++ interpretiert wird (wird die ersten Termine genutzt):

JupyterHub Link

• Ein Pointer kann (nacheinander) auf unterschiedliche Variablen zeigen:

int i1 = 5;
int i2 = 6;
int* ip = &i1;// ip zeigt auf i
// ...
ip = &i2;// ip zeigt auf i

Beispiel

int* ip = NULL; // ip ist int -Pointer
int a, *ap, b, *bp;// a, b sind int -Variablen ; ap , bp sind int-Pointer
int* x, y, z; // x ist int -Pointer; y, z sind int - Variablen

• Bei Pointern hat das Schlüsselwort const mehrere Bedeutungen:
  • Der Wert, auf den der Pointer verweist, soll nicht verändert werden: int const* ip;oder const int* ip;
  • Der Pointer soll nicht verändert werden, d. h., der Pointer kann nicht neu zugewiesen werden: int* const ip;
  • Wert und Pointer sollen nicht verändert werden: const int* const ip;

Der falsche Umgang mit Pointern ist eine der Hauptfehlerquellen in C!

Task: Was ist hier falsch?

int a = 0;
int* b = a;
*b = 1;

Addition einer Konstanten erhöht einen Pointer um ein Vielfaches der Größe des Basisdatentyps (Pointerarithmetik).

Betrachte:

char c;
int i;
printf( "&c = %p, &i = %p\n" , &c , &i );
printf( "&c + 1 = %p, &i + 1 = %p\n" , &c + 1, &i + 1 );

Wie lässt sich diese mögliche Ausgabe erklären?

&c = 0x7fff55f1cb2b , &i = 0x7fff55f1cb24
&c + 1 = 0x7fff55f1cb2c , &i + 1 = 0x7fff55f1cb28

• Der Umgang mit Pointern ist besonders am Anfang schwierig.
• C++ führt mit Referenzen ein ähnliches Sprachmittel ein.
• Wie Pointer sind Referenzen Variablen, die Verweise auf andere Variablen speichern.
• Der Typ einer Referenz auf eine Variable vom Typ T ist T&.

• Referenzen müssen immer sofort initialisiert werden:
• Eine Referenz kann nicht neu zugewiesen werden!
• Bei einer Zuweisung wird der referenzierte Wert überschrieben!

int i1 = 5;
int i2 = 6;
int& ir = i1; // ir zeigt auf i1
ir = i2; // ir zeigt immer noch auf i1 // i1 == i2

• Erinnerung: Die Parameterübergabe an Funktionen erfolgt in C (und C++) immer by value.
• Mit Pointern können wir jedoch call by reference simulieren.

Beispiel:

void swap( int* x, int* y) {
	int h = *x;
	*x = *y;
	*y = h;
}

int main( void ) {
	int i = 5;
	int j = 42;
	swap(&i, &j);// Achtung: Adressen auf i und j übergeben!
	printf( _"i = %i, j = %i\n"_ , i, j);
}

Task: Ist folgendes Programm korrekt?

int* foo( void )
{
	int result;
	result = 42;
	return &result;
}

• Pointer und Arrays sind in C++ eng verwandt.
• Entscheidend: Werte von Arrays liegen garantiert zusammenhängend im Speicher.

Es gibt dabei zwei wesentliche Dinge zu beachten:

• Eine Array-Variable verhält sich wie ein Pointer auf das erste Element des Arrays.
• Auf einen Pointer kann – wie auf ein Array – mit dem []-Operator zugegriffen werden.

int array [5];
int* ptr = array; // ptr == &( array[0])
int i0 = ptr [0]; // i0 == array[0] == *ptr
int i3 = ptr [3]; // i3 == array[3] == *(ptr+3)

• Allgemein gilt: ptr[i] == *(ptr+i)
• Zuweisungen an Array-Variablen sind nicht erlaubt!

Was macht die Funktion foo?

unsigned int foo( const char* s)
{
	const char* p = s;
	while ( *s ) ++s;
	return s - p;
}

int main( void )
{
	char test[] = "Hallo!";
	printf( "%i\n" , foo( test ));// gibt 6 aus
}

• Arrays können in C++ nicht by value an Funktionen übergeben werden.
• Stattdessen wird der Pointer auf das erste Element übergeben:

void foo( int* ip) {
	*ip = 23;
}

int main( void ) {
	int array[42];
	array[0] = 32;
	foo(array);
	printf( "%i\n" , array[0]); // gibt 23 aus
}

• Dabei ist es unerheblich, welche Syntax verwendet wird:

void foo( int* ip); // ip ist ein Pointer
void foo( int ip[]); // ip ist auch hier ein Pointer
void foo( int ip[42]);// ip ist auch hier ein Pointer

Im jupyter-book sind verschiedene Aufgaben angegeben:

Jupyter-Book Link

Hierüber kann dann direkt auf dem Hub eine Umgebung gestartet werden, in der C++ interpretiert wird (wird die ersten Termine genutzt):

JupyterHub Link

• Ein Zeiger (engl. Pointer) enthält die Adresse einer Variable im Speicher.
• Die Speicheradresse einer Variable liefert der Adressoperator &.
• Spezielle Adresse: NULL – „Zeiger ins Nichts“.
• Die Variable zu einem Pointer liefert der Dereferenzierungsoperator *.
• Der Typ eines Pointers auf eine Variable vom Typ T ist T*.

int a = 42;
int* b = &a; // Adressoperator angewendet auf a
*b = 12; // Dereferenzierungsoperator angewendet auf b; a == 12

• Eine Array-Variable verhält sich wie ein Pointer, der auf das erste Element des Arrays zeigt.
• Auf einen Pointer kann – wie auf ein Array – mit dem []-Operator zugegriffen werden. Dabei gilt: ptr[i] == *(ptr+i)
• Übergibt man einen Array-Typ T[] als Parameter an eine Funktion, „verfällt“ der Typ zum entsprechenden Pointer T* (Array Decaying).

• Der Umgang mit Pointern ist besonders am Anfang schwierig.
• C++ führt mit Referenzen ein ähnliches Sprachmittel ein.
• Wie Pointer sind Referenzen Variablen, die Verweise auf andere Variablen speichern.
• Der Typ einer Referenz auf eine Variable vom Typ T ist T&.

• Referenzen müssen immer sofort initialisiert werden:
• Eine Referenz kann nicht neu zugewiesen werden!
• Bei einer Zuweisung wird der referenzierte Wert überschrieben!

int i1 = 5;
int i2 = 6;
int& ir = i1; // ir zeigt auf i1
ir = i2; // ir zeigt immer noch auf i1 // i1 == i2

• Das Schlüsselwort const sollte bei Pointern und Referenzen verwendet werden, wenn auf ein Argument nur lesend zugegriffen wird:

void copy(const int& source, int& destination) { 
  destination = source;
}

int main() {
  int i = 5; int j; copy(i, j);
}

Erinnerung: Bei Pointern hat das Schlüsselwort const mehrere Bedeutungen:

• Der Wert, auf den der Pointer verweist, soll nicht verändert werden: int const* ip; oder const int* ip;
• Der Pointer soll nicht verändert werden, d. h., der Pointer kann nicht neu zugewiesen werden: int* const ip;
• Wert und Pointer sollen nicht verändert werden: const int* const ip;

• In C++ existieren die Operatoren new und delete.
• new erwartet einen Typ sowie (optional) Argumente für den Konstruktor und gibt einen Pointer des angegebenen Typs zurück: Widget* w = new Widget{args};
• delete ruft den Destruktor des angegeben Pointers auf und gibt den entsprechenden Speicherbereich frei: delete w;
• Um in C++ Speicher für ein Array anzufordern, gibt es den Operator new[].
• Entsprechend muss der Speicherbereich mit dem Operator delete[] freigegeben werden: Widget* widgets = new Widget[10]; ... delete[] widgets;