2. Programmsteuerung

Inhalt:

2.1 Logische Ausdrücke

Logische Ausdrücke werden zum Treffen von Entscheidungen benutzt
sind entweder wahr oder falsch
Darstellung in C: int-Zahl, 0 = falsch, <>0 = wahr
Darstellung in C++: wie in C, alternativ als Typ "bool": "true" = wahr, "false" = falsch
Zwischen der C-Darstellung mit "int" und der C++-Darstellung mit "bool" kann beliebig gewechselt werden.
Verknuepfen von logischen Ausdruecken: a&&b (a UND b), a||b (a ODER b), !a (NICHT a)

2.2 Kontrollstrukturen

In C++ genau wie in C
Grundelemente der Programmierung: Sequenz, Selektion, Iteration (und Rekursion?)
Ueblicherweise werden Befehle der Reihe nach abgearbeitet (Sequenz)

Auswahl: if

int a=2;
bool b;

if (a < 2) befehl;                // 1 Befehl
if (a == 2){ befehl1; befehl2; }  // Mehrere Befehle in einem Block


if (a = 1) ...                    // Achtung, Zuweisung!


b = a>5;                          // Wahrheitswert speichern
if (b == true) befehl;
if (b) ...


if (...)
    befehl;
else
    andererbefehl;    

    
if (...)
    befehl;
else if (...)
    befehl2;
else
    befehl3;

    
// Achtung, dangling else:
if (...)
  if (...) befehl;
else
  befehl2;
//
// Besser: 
if (...) {
  if (...) befehl;
} else {
  befehl2;
}

Auswahl: switch

int i; 
cin >> i;

switch (i) {   // Nur fuer Ganzzahlen (int, char, ...) definiert
case 1: cout << "1" << endl;
        break;
case 2: // Fall-through
case 3: cout << "2/3" << endl;
default: cout << "default" << endl;
}

Schleife: while

int i;                  // Variablendeklaration
i=1;                    // Initialisierung
while (i < 10) {        // Laufbedingung
  cout << i << endl;    // Eigentl. Schleifenkoerper
  i++;                  // Inkrement/Aktualisierung
}


struct listitem *p;
p = liste;
while (p != NULL) {
  cout << p->data << endl;
  p = p->next;
}


// Primzahlen von 1 bis 1000 ausgeben
int j = 0;
while(++j) {                 // Immer wahr - Endlosschleife
  if (!prime(j)) continue;   // sofort naechster Durchlauf
  if (j > 1000) break;       // sofort abbrechen
  cout << j << endl;
}

Schleife: for

int i,j;                  // Variablendeklaration
for (i = 1;               // Initialisierung
     i < 10;              // Laufbedingung
     i++ )                // Inkrement
     cout << i << endl;   // Schleifenkörper

for (j = 10; j > 0 ; j--) {
     cout << j << endl;
}


// Variablendeklaration -- nur in C++
for (int k = 0; k < 10 ; k++) {
     cout << k << endl;
}
for (struct listitem *p = liste; p != NULL; p=p->next)
     cout << p->data << endl;

Schleife: do-while

int i;
do {
  cin >> i;
  cout << i + 1;
} while(i != -1);

2.3 Funktionen

Definition Prototyp: typ name(typ variable, ...);
Prototypen machen Funktionen bzgl. Rückgabewert, Name und Parameter bekannt, ohne sie näher zu beschreiben. Oft in Header-Dateien (.h) abgelegt, die sowohl zur Implementierung (=> Überprüfung) als auch beim Benutzen (=> Bekanntmachen) benutzt werden.
Definition Funktion: typ name(typ variable, ...){ ... }
Aufruf: name(par1, par2);
Parameterübergabe: die beim Aufruf angegebenen Parameter werden als Kopie an die Funktion übergeben. Die Übergabe erfolgt üblicherweise über den Stack:
Beispielcode:
```
     void funktion(int);
     int a;
     funktion(17);
     a = 42; 
```
Ablauf:
Werterückgabe: Eine Funktion kann max. 1 Wert zurückgeben. Ist kein Wert benötigt so bietet sich als Rückgabewert "void" an. Bei mehreren Werten ist entweder mit Strukturen (structs) oder Zeigern zu arbeiten, siehe "Call by reference".

Rekursion: dadurch daß Parameter auf dem Stack übergeben werden, kann eine Funktion such auch beliebig selbst aufrufen. Wichtig ist, daß ein Abbruchkriterium für die Rekursionstiefe existiert, da sonst ein sog. Stack-Overflow geschieht:

Beispiele:

int main(void) {
    main();         // Bumm!
}


// Zaehlen ohne Schleife (Source):
void count_forward(int i) {
    if (i > 0)
        count_forward(i - 1);
    cout << i << " ";
}
void count_backwards(int i) {
    cout << i << " ";
    if (i > 0)
        count_backwards(i - 1);
}
int main()
{
    count_forward(10);   cout << endl;
    count_backwards(10); cout << endl;
    return 0;
}

Ausgabe:

% ./rekursiv-zaehlen 
0 1 2 3 4 5 6 7 8 9 10 
10 9 8 7 6 5 4 3 2 1 0

Stackaufbau (gross):

Statische Variablen: Speicher für "normale" (auto) Variablen wird beim Betreten eines Blocks auf dem Stack belegt. Damit ist auch der Speicher nach Ende der Funktion freigegeben. In Funktionen als "static" deklarierte Variablen erhalten ihren Wert über Funktionsaufrufe hinweg:
```
     int zaehler(void)
     {
         static int meinZaehler = 1;
	 return meinZaehler++;
     } 
```

Funktionen überladen: Im Gegensatz zu C können in C++ mehrere Funktionen mit demselben Namen existieren, die sich lediglich in Anzahl und Typ der Parameter unterscheiden:

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

Funktionen die dieselben Parameter besitzen und sich lediglich im Rückgabewert unterscheiden sind in C++ nicht möglich, da Rückgabewerte in C++ genau wie in C ignoriert bzw. nicht benutzt werden müssen, und so nicht eindeutig feststellbar wäre, welche Funktion aufgerufen werden soll:

     int f(void);
     double f(void);

     f();  // welche Funktion aufrufen? Geht nicht!

Hintergrund:

Symbole in C:

% cat ov-C.c 
int max(int a, int b)      { return (a > b)?a:b; }
% cc -c ov-C.c
% nm ov-C.o
00000000 T max

Symbole in C++:

% cat ov-C++.cc 
int max(int a, int b)      { return (a > b)?a:b; }
double max(double a, double b){ return (a > b)?a:b; } 
% cc -c ov-C++.cc
% nm ov-C++.o
00000022 T _Z3maxdd
00000000 T _Z3maxii
         U __gxx_personality_v0
% nm ov-C++.o | c++filt 
00000022 T max(double, double)
00000000 T max(int, int)
         U __gxx_personality_v0

Default-Argumente: Funktionsparameter können in C++ mit Werten vorbesetzt werden, falls sie beim Aufruf nicht angegeben sind. Der Compiler besetzt dann beim aufruf die fehlenden Parameter:

     void WetterMelder(char *grund, char *ton = NULL, int lautstaerke=100){
         popupFenster(grund);
         if (ton != NULL)
             soundSpielen(ton, lautstaerke);
     }

     main() {
         WetterMelder("Regen");
         WetterMelder("Sonnenschein", "/mp3/beachboys - like ice in the sunshine.mp3");
         WetterMelder("Wolken", "/mp3/donnergrollen.mp3", 50);

	 WetterMelder("Schnee", 10); // XXX Geht nicht!
     }

Call by reference, call by value: Genau wie in C

Ziel: Vertauschen zweier Variablen a und b

    void tausch (int a, int b)
    {
        int temp;
    
        temp = a;
        a = b;
        b = temp;
    }

    int main(void)
    {
        int x = 1, y = 2;
	printf("x = %d, y = %d\n", x,y);
        tausch (x,y);
	printf("x = %d, y = %d\n", x,y);
	return 0;
    }

Problem: Funktion arbeitet auf Kopien, dadurch sinnlos

Lösung: Zeiger verwenden!

    void tausch (int *za, int *zb)
    {
        int temp;
    
        temp = *za;
        *za = *zb;
        *zb = temp;
    }

    int main(void)
    {
        int x = 1, y = 2;
	printf("x = %d, y = %d\n", x,y);
        tausch (&x,&y);
	printf("x = %d, y = %d\n", x,y);
	return 0;
    }

Vorteil: Funktioniert (:-), Tatsache daß in die Funktion übergebene Werte verändert werden können ist anhand der Zeiger ersichtlich.

Nachteil: Umstaendliches hantieren mit Zeigern sowohl beim Aufruf als auch beim Schreiben der Funktion.

2.4 Referenzen

C++ bietet eine alternative Lösung für "call by reference": Referenzen

    void tausch (int &ra, int &rb)
    {
        int temp;
    
        temp = ra;
        ra = rb;
        rb = temp;
    }

    int main(void)
    {
        int x = 1, y = 2;
	printf("x = %d, y = %d\n", x,y);
        tausch (x, y);
	printf("x = %d, y = %d\n", x,y);
	return 0;
    }

Referenzen sind intern mit Zeigern implementiert, verbergen dies jedoch vor dem Programmierer -- bei Funktionen sowohl beim Aufruf als auch beim Schreiben von Funktionen.
Durch das Verwenden von Zeigern werden keine Elemente kopiert, was v.a. bei größeren structs einen Geschwindigkeitsvorteil bringt - das Übergeben von Zeiger und Referenzen ist damit unabhängig von der Größe der struct.

Referenzen können auch als "normale" Variablen benutzt werden, sind dann jedoch sofort zu initialisieren:

% cat src/referenz.cc 
#include <iostream>
using namespace std;
int main(void)
{
        int i;
        int &ri = i;
        i = 42;
        ri = 17;
        cout << i << endl;
        return 0;
}
% c++ src/referenz.cc -o src/referenz
% src/referenz 
17

Vorteil: schnell, weniger Tippaufwand beim Schreiben und Aufrufen von Funktionen
Nachteil: nicht immer sofort als solches erkennbar, v.a. bei Aufruf fremder Funktionen

2.5 Modularisierung

Große Programme können in mehrere Dateien = Module aufgesplittet werden, der Compiliervorgang kann dann z.B. mit Hilfe von Makefiles abgebildet werden:

Abgesehen vom Compiler-Aufruf funktiniert dies in C++ genau wie in C.
Die einzelnen Module werden in Object-Files (.o) compiliert (c++ -c), und anschließend vom Linker zusammen mit diversen Bibliotheken zu ausführbaren Programmen gebunden ("gelinkt"; c++ -o).
Funktionen und (globale) Variablen sind vorerst nur innerhalb des Moduls bekannt, können jedoch durch Prototypen und "extern"-Deklaration auch auf andere Module zugreifen:
```
     void funktionImAnderenModul(int i);
     extern int variableImAnderenModul; 
```
Wenn auf gemeinsame Funktionen und Variablen von mehreren (üblich: >= 2) Modulen zugegriffen werden soll empfiehlt es sich, die reinen Deklarationen in eine einzelnen Header-Datei (bla.h) abzulegen, und via #include "bla.h" zu benutzen.
Damit eine Funktion oder globale Variable von anderen Modulen benutzt werden kann muß keine besondere Anweisung gegeben werden.

Um zu verhindern dass eine Funktion oder globale Variable von anderen Modulen benutzt wird, sind diese als static zu deklarieren:

     static int privateVariable=0;
     static int privateFunktion(void) {
         return privateVariable++;
     }
     int oeffentlicherZaehler(void){
         return privateFunktion();
     }

2.6 Ausnahmen (Exceptions)

Problem: Normalerweise sollte jeder Funktionsaufruf auf Erfolg überprüft werden, und eventuelle Fehler abgefangen werden. Für eine Zeile Programmfunktionalität sind somit mehrere Zeilen Fehlerabfrage nötig, die zudem den Programmfluß schwer erkennbar machen. Dies macht die Wartung des Programmes schwierig.
Lösung: C++ bietet mit Ausnahmen (Exceptions) einen Ansatz, dies lesbarer zu machen. Es wird dabei erst in einem try-Block versucht, Anweisungen auszuführen. Geschieht ein Fehler, wird dieser nicht als Return-Code einer Funktion zurückgegeben, sondern mittels catch(). Der Fehler entspricht dabei einem bestimmten Datentypen -- üblicherweise einer struct oder Klasse -- die nähere Angaben zum Fehler enthält.
Im Fehlerfall wird die aufrufende Funktion den Fehler zu behandeln. Kann sie mit der gefangenen Fehlerklasse nichts anfangen, so wirft sie sie weiter an die aufrufende Funktion, den Call-Stack hinauf.
Ausnahmen unbekannten Typs können mittels "catch(...)" gefangen werden.

Beispiel (Quellcode):

#include <iostream>
using namespace std;

void func(int i)
{
    try {
	if (i == 1) throw 1;
	if (i == 2) throw 17.42;
	if (i == 3) throw 'a';
    }
    // Integer-Exceptions können selbst abgefangen werden
    catch(int a) {
	cout << "Caught integer exception:  " << a << endl;
	return;
    }
    cout << "No integer exception detected, i = " << i << endl;
    return;
} 

int main(void)
{
    try {
	func(0);
	func(1);
	func(2);
	func(3);
	func(4);
    }
    // Ausnahmen behandeln, die die Funktion nicht selbst behandeln konnte:
    catch (double x) {
	cout << "Caught double exception: " << x << endl;
    }
    catch (char c) {
	cout << "Caught char exception: " << c << endl;
    }
    catch (...) {
	cout << "Caught unknown exception" << endl;
    }
    
    return 0;
}

Ausgabe:

% src/exception
No integer exception detected, i = 0
Caught integer exception:  1
Caught double exception: 17.42

Mehr Informationen: "C++ Exception Handling" von Denton Woods, Stand 10.1.2007

2.7 Datenstrukturen (structs)

structs funktionieren wie in C, vgl. Kapitel komplexe Datentypen und dynamische Datenstrukturen
Wie gehabt können structs als Funktionsparameter an Funktionen übergeben und zurückgegeben und mittels malloc(3) dynamisch belegt werden.
Die in C++ neuen Klassen ("class") entsprechen effektiv den structs, bis auf die Default-Zugriffsrechte (struct: public; class: private). Mehr zu Klassen im folgenden Kapitel!

2.8 Beispiele

Reihe der Fibonacci-Zahlen rekursiv berechnen (Jobst Blatt 5.3.1, Loesung)
Betrachten Sie die Anleitung zur Turtle-Grafik!
Zeichnen Sie das Haus vom Nikolaus mit Hilfe der Turtle-Grafik-Routinen (Jobst Blatt 4.4, Java-Loesung, C++-Loesung)
Zeichnen Sie eine Koch'sche Schneeflocke mit Hilfe der Turtle-Grafik (Loesung: koch.cc)

2.9 Übungen

Schreiben Sie eine Funktion betrag(), die den Betrag (Absolutwert) einer übergebenen Zahl zurückgibt (Jobst Blatt 5.1.2)
Schreiben Sie eine Funktion kubik(), die die dritte Potenz (x^3) einer übergebenen Zahl zurückgibt (Jobst Blatt 5.1.1)
3n+1 Problem (Schicker Blatt 1.2)
ggT rekursiv (Schicker Blatt 1.4)
Liste von Armstrong-Zahlen (Schicker Blatt 2.9)
Zeichnen Sie einen Mäander mit Hilfe der Turtle-Grafik-Routinen (Jobst Blatt 4.4)
Zeichnen Sie ein Sierpinski-Dreieck mit Hilfe von fertigen Routinen Turtle-Grafik (Jobst Blatt 5.4)
Zeichnen Sie den Weg eines Betrunkenen mit Hilfe von Turtle-Grafik nach. Der Betrunkene geht dabei ein paar Schritte, dreht sich dann in eine zufaellige Richtung, und geht dann weiter. Hinweis: Zufallszahlen erhalten Sie mit Hilfe der rand(3) Funktion.
Diverse Aufgaben zur Polymorphie (Sauer Test Nr. 3)
Diverse Aufgaben zur Rekursion (Sauer Test Nr. 4)