Contents

Einführung

Ziel der Vorlesung

Aufbau der Vorlesung

Chapter 1
Die Programmiersprache C++

1.1  Geschichtlicher Abriss

1.2  Compiler und Werkzeuge

1.2.1  Editoren

1.2.2  Compiler

gcc

Borland

Microsoft

1.3  Kompilieren und Ausführen

• Übersetzung: Ein C Compiler betrachtet immer genau ein C-Programm, das in genau einer Datei steht. Alle Informationen müssen in dieser Datei enthalten sein. Anders als beim Javacompiler, der unter der Hand auf Klassendateien, die mitunter in einer jar-Datei verpackt sind, zugreift, implizit die Standardklassen mit berücksichtigt und mehrere Javadateien auf einen Rutsch übersetzt.
• Ausführung: Der C Compiler erzeugt direkt maschinenabhängigen ausführbaren Programmcode. Es wird kein weiteres Programm, das eine virtuelle Maschine interpretiert, benötigt.

1.3.1  Das übliche Programm: hello world

#include  <iostream> 
 

int main(){
  std::cout << "Hallo Welt\n";
}

#include <iostream>

int main(){
  std::cout << "Hallo " << "Welt" << std::endl;
}

1.3.2  Kompilieren

sep@swe10:~/fh/prog3/examples> g++ -o Hello1 Hello1.cpp
sep@swe10:~/fh/prog3/examples> ./Hello1
Hallo Welt
sep@swe10:~/fh/prog3/examples>

1.4  Funktionen und Variablen

1.4.1  Schreiben von Funktionen

#include <iostream>
#include <string>

std::string getHallo(){
  return "hallo welt\n";
};

int main(){
  std::cout <<getHallo();
}

#include <iostream>
#include <string>

int main(){
  std::cout << getHallo();
}

std::string getHallo(){
  return "hallo welt\n";
}

sep@swe10:~/fh/prog3/examples> g++ Hello3.cpp
Hello3.cpp: In function `int main(...)':
Hello3.cpp:6: implicit declaration of function `int getHallo(...)'
sep@swe10:~/fh/prog3/examples>

#include <iostream>
#include <string>

std::string getHallo();

int main(){
  std::cout << getHallo();
}

std::string getHallo(){
  return "hallo welt\n";
}

Header-Dateien

#include <string>

std::string getHallo();

#include <iostream>
#include <string>

#include "Hello5.h"

int main(){
  std::cout << getHallo();
}

std::string getHallo(){
  return "hallo welt\n";
}

Objektdateien und Linker

#include <iostream>
#include "Hello5.h"

int main(){
  std::cout << getHallo();
}

sep@swe10:~/fh/prog3/examples> g++ -c Hello6.cpp
sep@swe10:~/fh/prog3/examples> ls -l Hello6.*
-rw-r--r--    1 sep      users          84 Sep  3 17:36 Hello6.cpp
-rw-r--r--    1 sep      users        8452 Sep  3 17:40 Hello6.o
sep@swe10:~/fh/prog3/examples>

sep@swe10:~/fh/prog3/examples> g++ Hello6.cpp
/tmp/ccRKWUqK.o: In function `main':
/tmp/ccRKWUqK.o(.text+0xe): undefined reference to `getHallo(void)'
collect2: ld returned 1 exit status
sep@swe10:~/fh/prog3/examples>

#include <iostream>
#include <string>

std::string getHallo();

int main(){
  std::cout << getHallo();
}

sep@swe10:~/fh/prog3/examples> g++ Hello7.cpp
/tmp/ccdm3ngO.o: In function `main':
/tmp/ccdm3ngO.o(.text+0xe): undefined reference to `getHallo(void)'
collect2: ld returned 1 exit status
sep@swe10:~/fh/prog3/examples>

1.4.2  Variablen

#include <iostream>

int i = 2;

void f(int j){
  int k = 2*j;
  i=i+k;
}

int j = 2;

int main(){
  std::cout << i <<  std::endl;
  f(15);
  std::cout << i <<  std::endl;
  f(5);
  std::cout << i <<  std::endl;
  std::cout << j <<  std::endl;
}

Mehrfach inkludieren

int x =0;

#include "C1.h"

#include "C1.h"
#include "C2.h"

int main(){};

sep@linux:~/fh/prog3/examples/src> g++ -c C3.cpp
In file included from C2.h:1,
                 from C3.cpp:2:
C1.h:1: error: redefinition of `int x'
C1.h:1: error: `int x' previously defined here
sep@linux:~/fh/prog3/examples/src>

#ifndef __D1_H

#define __D1_H ;

int x =0;

#endif /* __D1_H */

#include "D1.h"

#include "D1.h"
#include "D2.h"

int main(){};

sep@linux:~/fh/prog3/examples/src> g++ -o D3 D3.cpp
sep@linux:~/fh/prog3/examples/src> ./D3

Chapter 2
Typen

2.1  Zeiger und Referenzen

2.1.1  Der Speicher

• tatsächlich eine Zahl im herkömmlichen Sinne.
• als ein Wert eines anderen primitiven Typs, als die diese Zahl interpretiert wird, z.B. einen Zeichen in einem Zeichensatz.
• als die Adresse einer Speicherzelle.
• als ein Befehl der Maschinensprache des Prozessors.

2.1.2  Zeiger

Deklaration von Zeigertypen

Erzeugen von Zeigern

Beispiel:
Wir deklarieren drei Variablen: eine vom Typ int, einen Zeiger auf eine Variable vom Typ int und einen Zeiger auf eine Variable, die wieder ein Zeiger ist. Für alle drei Variablen werden die Werte ausgegeben.

#include <iostream>

int main(){
  int i = 5;
  int* pI = &i;
  int** ppI = &pI;
  
  std::cout << i 
    << ", " << pI 
    <<", "  << ppI 
    << std::endl;
}

sep@swe10:~/fh/prog3/examples> ./Zeiger1
5, 0xbffff1b8, 0xbffff1b4
sep@swe10:~/fh/prog3/examples>

Zeiger auflösen

Beispiel:
Mit dem Operator * läßt sich wieder der Wert der Speicherzelle, auf den ein Zeiger weist, erhalten.

#include <iostream>

int main(){
  int i = 5;
  int *pI = &i;
  int **ppI = &pI;
  
  std::cout << i 
    << ", " << pI 
    << ", " << *pI 
    <<", "  << ppI 
    << ", " << *ppI 
    << ", " << **ppI
    << std::endl;
}

sep@swe10:~/fh/prog3/examples> ./Zeiger2
5, 0xbffff1b8, 5, 0xbffff1b4, 0xbffff1b8, 5
sep@swe10:~/fh/prog3/examples>

Zuweisungen auf Speicherzellen

Beispiel:
Wir verändern eine Variable einmal dirket und zweimal über Zeiger auf diese Variable.

#include <iostream>

int main(){
  int i = 5;
  int *pI = &i;
  int **ppI = &pI;
  std::cout << i << ", " << *pI << ", " << **ppI << std::endl;

  i = 10;
  std::cout << i << ", " << *pI << ", " << **ppI << std::endl;

  *pI = 20;  
  std::cout << i << ", " << *pI << ", " << **ppI << std::endl;

  **ppI = 42;  
  std::cout << i << ", " << *pI << ", " << **ppI << std::endl;
}

sep@swe10:~/fh/prog3/examples> ./Zeiger3
5, 5, 5
10, 10, 10
20, 20, 20
42, 42, 42
sep@swe10:~/fh/prog3/examples>

Rechnen mit Zeigern

Beispiel:
Wir erzeugen mehrere Zeiger auf ganze Zahlen und betrachten die Nachbarschaft eines dieser Zeiger.

#include <iostream>

int main(){
  int i = 5;
  int j = 42;
  int *pI = &i;
  int *pJ = &j;
  
  int *pK;

  std::cout << i 
    << ", " << pI 
    << ", " << pI+1 
    <<", "  << *(pI+1) 
    << ", " << pI-1 
    <<", "  << *(pI-1) 
    << ", " << pJ 
    << ", " << *pJ 
    << std::endl;

  *pK = 12;
    std::cout << pK <<", " << *pK << std::endl; 
}

sep@swe10:~/fh/prog3/examples> ./Zeiger4
5, 0xbffff1b8, 0xbffff1bc, -1073745416, 0xbffff1b4, 42, 0xbffff1b4, 42
0xbffff1c8, 12
sep@swe10:~/fh/prog3/examples>

Zeiger als Parameter

Beispiel:
Folgendes Javaprogramm gibt die 0 und nicht die 42 aus.

class JIntAssign {
  static void f(int x){x=42;}

  public static void main(String [] _){
    int y = 0;
    f(y);
    System.out.println(y);
  }
}

#include <iostream>

void f(int x){x=42;}

int main(){
  int y = 0;
  f(y);
  std::cout << y << std::endl;
}

#include <iostream>

  void f(int* pX){*pX=42;}

  int main(){
    int y = 0;
    int *pY = &y;
    f(pY);
    std::cout << y << std::endl;
  }

Beispiel:
Eine typische Klasse, die nur Objekte für eine ganze Zahl erzeugt:

class IntBox{
  int value;
  public IntBox(int v){value=v;}
}

class JIntBoxAssign {
  static void f(IntBox xBox){xBox.value=42;}
  public static void main(String [] _){
    IntBox yBox = new IntBox(0);
    f(yBox);
    System.out.println(yBox.value);
  }
}

void fak(int x,int* result);

Dynamisch Adresse anfordern

Beispiel:
new ist gefährlich, denn jedesmal, wenn der Operator new ausgeführt wird, bekommen wir eine frische Speicherzelle für die Programmausführung zugewiesen. Wenn wir das wiederholt machen, so werden wir immer mehr Speicher vom Betriebssystem anfordern. Irgendwann wird das Betriebssystem keinen Speicher mehr zur Verfügung stellen können. Folgendes Programm durchläuft eine Schleife und fordert jedesmal eine neue Speicherzelle an.

#include <iostream>

int main(){
    while (true){
	int *pX = new int;
        std::cout << pX << std::endl;
    }
}

Beispiel:
Das Speicherloch des letzten Beispiels läßt sich schließen, indem der Zeiger nach seiner Ausgabe immer wieder gelöscht, d.h. dem Betriebssystem zurückgegeben wird.

#include <iostream>

int main(){
    while (true){
	int *pX = new int;
        std::cout << pX << std::endl;
        delete pX;
    }
}

Beispiel:
Wir erzeugen mit new einen Zeiger. Diesen Zeiger kopieren wir in einen zweiten Zeiger, über den schließlich die Speicherzelle wieder freigegeben wird. Jetzt haben wir einen Zeiger pI, dessen Zieladresse vom Programm neu verwendet werden kann.

#include <iostream>

void f(int* pI){
  int* pX = pI;
  delete pX;
}

int main(){
  int *pI = new int;
  *pI = 42;
  std::cout << *pI << std::endl;
  f(pI);
  int *pK = new int;
  *pK = 16;
  std::cout << *pI <<  std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ -o WrongDelete WrongDelete.cpp
sep@linux:~/fh/prog3/examples/src> ./WrongDelete
42
16
sep@linux:~/fh/prog3/examples/src>

Zeiger auf lokale Variablen

Beispiel:
Betrachten wir folgendes Programm. Die Funktion refToSquare hat als Rückgabewert einen Zeiger auf ihre lokale Variable j.

#include <iostream>

int*  refToSquare(int i){
  int j = i*i;
  return &j;
}

int main(){
  int *pJ = refToSquare(5);
  int k = 42;
  std::cout << k <<std::endl;
  std::cout << *pJ <<std::endl;
}

sep@linux:~/fh/prog3/examples/src> c++ -o LocalVarPointer LocalVarPointer.cpp
LocalVarPointer.cpp: In function `int* refToSquare(int)':
LocalVarPointer.cpp:4: Warnung: address of local variable `j' returned
sep@linux:~/fh/prog3/examples/src>

sep@linux:~/fh/prog3/examples/src> ./LocalVarPointer
42
-1073745324
sep@linux:~/fh/prog3/examples/src>

2.1.3  Funktionszeiger

Beispiel:
Wir definieren eine einfache Funktion, die 5 auf eine Zahl addiert. Wir greifen auf diese Funktion über ihren Adresszeiger in der Anwendung zu.

#include <iostream>

int add5(int x){return x+5;}

int main(){
  int (*f) (int) = &add5;
  int i = (*f)(4);

  std::cout << i << std::endl;
}

#include <iostream>

int add5(int x){return x+5;}

int main(){
  int (*f) (int) = add5;
  int i = f(4);

  std::cout << i << std::endl;
}

#include <iostream>

int f(){
    return 1+1+1+1+1+1+1+1+1+1+1+1;
}

int eval(int (*f)()){
    return f();
}

int main(){
  std::cout << eval(*f + 8) << std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ WrongPointerArith.cpp
WrongPointerArith.cpp: In function `int main()':
WrongPointerArith.cpp:12: error: pointer to a function used in arithmetic
sep@linux:~/fh/prog3/examples/src>

float nullstelle(float (*f) (float),float mi,float ma);

#include "Nullstellen.h"
#include <iostream>

float f1(float x){return 2*x*x*x+5;}
float f2(float x){return 2*x +1 + x*x*x/4 ;}
float f3(float x){return 10*x+5;}
float f4(float x){return 0;}
float f5(float x){return x*x;}

void teste(float (*f)(float)){
  const float fn = nullstelle(f,-10,11);
  std::cout << "n = "<<fn<< ", f(n) = " << f(fn) << std::endl;
}

int main(){
  teste(f1);
  teste(f2);
  teste(f3);
  teste(f4);
  teste(f5);
}

2.1.4  Synonyme Typnamen

Beispiel:
Ein einfaches Typsynonym für Zahlen:

#include <iostream>

typedef int zahl;

zahl f(zahl x){return 2*x;}

int main(){
  std::cout << f(21) << std::endl;
}

Beispiel:
Für führen ein Synonym für Funktionen auf float-Werten ein:

#include <iostream>

typedef float zahl;
typedef zahl (*zahlenFunktion)(zahl);

zahl verdoppel(zahl x){return 2*x;}

zahl applyTwice(zahlenFunktion f, zahl x){
  return f(f(x));
}

int main(){
  std::cout << applyTwice(verdoppel,10.5) << std::endl; 
}

• Es lassen sich sprechende Typnamen erfinden, die das Programm lesbarer machen.
• Man kann einen konkreten Typ leicht ändern, wenn man im gesamten Programm nur mit dem Typsynonym arbeitet; so kann man z.B. ein Typsynonym zahl einführen und legt nur in dessen Definition fest, ob es sich um eine int oder long Zahl handelt.
• Unhandliche C Typen, die aus mehreren Teilen bestehen, lassen sich durch ein Wort ausdrücken.

2.1.5  Referenzen

Deklaration von Referenztypen

Initialisierung

int &i;

sep@linux:~/fh/prog3/examples/src> g++ -c NoInitRef.cpp
NoInitRef.cpp:1: error: `i' declared as reference but not initialized
sep@linux:~/fh/prog3/examples/src>

int i;
int &j=i;

int i;
int &j1=i+2;
int &j2=2;

sep@linux:~/fh/prog3/examples/src> g++ -c WrongInitRef.cpp
WrongInitRef.cpp:2: error: could not convert `(i + 2)' to `int&'
WrongInitRef.cpp:3: error: could not convert `2' to `int&'
sep@linux:~/fh/prog3/examples/src>

Benutzung

#include <iostream>
int  main(){
    int i=42;
    int &j=i;
    std::cout << j << std::endl;
    i=i+1;
    std::cout << j << std::endl;
    i=i-1;
    std::cout << j << std::endl;
    int k=j;
    std::cout << k << std::endl;
    i=i+1;
    std::cout << k << std::endl;
}

sep@linux:~/fh/prog3/examples/src> ./ModifyOrg
42
43
42
42
42
sep@linux:~/fh/prog3/examples/src>

#include <iostream>

int main(){
  int i = 21;
  int &j=i;
  
  j=2*j;
  std::cout << i << ", "<< j << std::endl;
}

sep@linux:~/fh/prog3/examples/bin> ./ModifyRef
42, 42
sep@linux:~/fh/prog3/examples/bin>

#include <iostream>

int main(){
  int i1 = 21;
  int &j1=i1;

  int i2 = 42;
  int &j2=i2;  
  std::cout << i2 <<", "<< j2 << std::endl;

  j2 = j1;
  std::cout << i2 <<", "<< j2 << std::endl;

  j2 = 15;
  std::cout << i1 <<", "<< j1 << std::endl;
  std::cout << i2 <<", "<< j2 << std::endl;
}

sep@linux:~/fh/prog3/examples/src> ./RefToRef
42, 42
21, 21
21, 21
15, 15
sep@linux:~/fh/prog3/examples/src>

Referenzen als Funktionsparameter

#include <iostream>

void f(int &x){
  x=x+1;
}

int main(){
  int i = 41;
  f(i);
  std::cout << i << std::endl;
}

sep@linux:~/fh/prog3/examples/bin> ./RefArg
42
sep@linux:~/fh/prog3/examples/bin>

#include <iostream>

void f(int &x){}

int main(){
  int i = 41;
  f(i+1);
  f(1);
}

sep@linux:~/fh/prog3/examples/src> g++ -c WrongCall.cpp
WrongCall.cpp: In function `int main()':
WrongCall.cpp:8: error: could not convert `(i + 1)' to `int&'
WrongCall.cpp:3: error: in passing argument 1 of `void f(int&)'
WrongCall.cpp:9: error: could not convert `1' to `int&'
WrongCall.cpp:3: error: in passing argument 1 of `void f(int&)'
sep@linux:~/fh/prog3/examples/src>

2.2  Konstruierte Typen

2.2.1  Aufzählungen

Beispiel:
Wir definieren ein Aufzählung von 6 Farben und benutzen diese.

#include <iostream>

enum farben 
  {rot, gruen, gelb, blau, magenta, umbra};

int main() {
  enum farben f = gelb;

  std::cout << f <<std::endl;
  if (f== gelb) std::cout << "gelbe Farbe" <<std::endl;
  if (f== umbra) std::cout << "Farbe umbra" <<std::endl;
  if (f> rot) std::cout << "Farbe größer Rot" <<std::endl;
  f=(farben)(f+1);
  std::cout << f << std::endl;
  if (f== blau) std::cout << "blaue Farbe" <<std::endl;
  if (f> gelb) std::cout  << "Farbe größer Gelb" <<std::endl;
  f=gruen;
  std::cout << f << std::endl;

  f=(farben)(10);
  std::cout << "die Farbe 10: " << f << std::endl;
}

sep@linux:~/fh/prog3/examples/bin> ./Farben
2
gelbe Farbe
Farbe größer Rot
3
blaue Farbe
Farbe größer Gelb
1
die Farbe 10: 10
sep@linux:~/fh/prog3/examples/bin>

#include <iostream>

int main(){
  std::cout << true << std::endl;
  std::cout << false << std::endl;

  if (10) std::cout << "10 ist wahr" << std::endl;
  if (0) ; else std::cout << "0 ist falsch" << std::endl;
}

#include <iostream>

enum wahrheit {falsch, wahr};

int main(){
    if (wahr) std::cout << "wahr" << std::endl;

    wahrheit w = (wahrheit)(falsch||wahr);
    if (w) std::cout << "wahr" << std::endl;

    w = (wahrheit)(falsch&&wahr);   
    if (w) std::cout << "wahr" << std::endl;

    w=(wahrheit)(1==1);
    if (w) std::cout << "wahr" << std::endl;
}

2.2.2  Reihungen (Arrays)

#include <iostream>

int main(){
  int xs [] = {1,2,3};
  std::cout << xs[1];
}

int main(){
  int [] xs = {1,2,3}; // Java Syntax
}

Größendeklaration

int main(){
  int xs [];
}

sep@linux:~/fh/prog3/examples/src> g++ UnknownSize.cpp
UnknownSize.cpp: In function `int main()':
UnknownSize.cpp:2: error: storage size of `xs' isn't known
sep@linux:~/fh/prog3/examples/src>

#include <iostream>

int main(){
  int xs [15];
  std::cout << xs[1];
}

class ArrayTest {

    public static void main(String [] _){
	int [] ys = {1,2,3};
	int [] zs;
    }
}

#include <iostream>

void f(int l){
  int xs [l];
  for (int i= 0; i<l;i=i+1){
    xs[i]=i;
    std::cout << xs[i] << ",";
  }
  std::cout << std::endl;
}

int main(){
  f(7);
  f(2);
}

sep@linux:~/fh/prog3/examples/src> ./LocalArray
0,1,2,3,4,5,6,
0,1,
sep@linux:~/fh/prog3/examples/src>

Die Größe einer Reihung

class ArrayLength {

  public static void main(String [] _){
    int xs [] = {1,2,3};
    System.out.println(xs.length);
  }
}

#include <iostream>
#include <cstddef>


int main(){
  int xs [] = {1,2,3};
  double ys [] = {1,2,3};

  size_t xsSize   = sizeof(xs);
  size_t xsLength = xsSize/sizeof(xs[0]);

  size_t ysSize   = sizeof(ys);
  size_t ysLength = ysSize/sizeof(ys[0]);

  std::cout << "xsSize:   " << xsSize   << std::endl;
  std::cout << "xsLength: " << xsLength << std::endl;
  std::cout << "ysSize:   " << ysSize   << std::endl;
  std::cout << "ysLength: " << ysLength << std::endl;
}

sep@linux:~/fh/prog3/examples/bin> ./CArrayLength
xsSize:   12
xsLength: 3
ysSize:   24
ysLength: 3
sep@linux:~/fh/prog3/examples/bin>

Zaunpfahlprobleme

class WrongIndex {
  public static void main(String [] _){
    String [] xs = {"hallo", "was", "kommt", "jetzt"};
    for (int i=0;i<=xs.length;i++){
      System.out.println(xs[i]);
    }
  }
}

sep@linux:~/fh/prog3/examples/classes> java WrongIndex
hallo
was
kommt
jetzt
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
        at WrongIndex.main(JWrongIndex.java:5)
sep@linux:~/fh/prog3/examples/classes>

#include <iostream>

int main(){
  std::string xs []  = {"hallo", "was", "kommt", "jetzt"};
  for (int i=0;i<=4;i++){
    std::cout <<xs[i]<< std::endl;
  }

  int ys []  = {1,2,3,4};
  for (int i=0;i<=4;i++){
    std::cout <<ys[i]<< std::endl;
  }
}

sep@linux:~/fh/prog3/examples/bin> ./CWrongIndex
hallo
was
kommt
jetzt

1
2
3
4
1074641520
sep@linux:~/fh/prog3/examples/bin>

Reihungszuweisung

class JAssignAndModify{
   public static void main(String [] _){
     int [] xs = {1,2,3};
     int [] ys = xs;
     ys[1]=42;
     System.out.println(xs[1]);
  }
}

#include <iostream>
int main(){
  int xs [] = {1,2,3};
  int ys [3];
  ys = xs;
  ys[1]=42;
  std::cout <<xs[1]<<std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ IllegalAssign.cpp
IllegalAssign.cpp: In function `int main()':
IllegalAssign.cpp:5: error: ISO C++ forbids assignment of arrays
sep@linux:~/fh/prog3/examples/src>

#include <iostream>
int main(){
  int xs [3] = {1,2,3};
  int (* pXs)[3]  = &xs;
  int (* pYs)[3]  = pXs;

  (*pYs)[1] =42;

  std::cout << xs[1] << std::endl;
}

Reihungen von Zeigern

#include <iostream>

int main(){
  int *xs [] = {new int, new int, new int};
  for (int i = 0;i<3;i=i+1){
    *xs[i] = i;
  }

  for (int i = 0;i<3;i=i+1){
      std::cout << xs[i] << " " <<*xs[i] << std::endl;
  }
}

sep@linux:~/fh/prog3/examples/src> g++ -o ArrayOfPointers ArrayOfPointers.cpp
sep@linux:~/fh/prog3/examples/src> ./ArrayOfPointers
0x8049cd8 0
0x8049ce8 1
0x8049cf8 2
sep@linux:~/fh/prog3/examples/src>

typedef int (* intfunction)(int);

int compose(intfunction fs [],int length,int x);

compose({f₁,... f_n},n,x) = f_n(f_n-1(...(f₁(x))...))

#include <iostream>
#include "Compose.h"

int f1(int x){return x*x;}
int f2(int x){return x;}
int f3(int x){return x+2;}
int f4(int x){return x*4;}
int f5(int x){return -x*x*x;}

int main(){
    intfunction fs [] = {f1,f2,f3,f4,f5};
    std::cout << compose(fs,5,2)<<std::endl;
}

Dynamische Reihungen

Beispiel:
Folgendes Programm erzeugt dynamisch nacheinander meherere Reihungen, benutzt diese kurz und gibt anschließend den durch die Reihung belegten Speicherbereich wieder frei:

#include <iostream>

int main(){
  for (int i = 10; i<20;i=i+1){
    int *xs = new int[i];
    for (int j = 0; j<i;j=j+1){
      xs[j]=j;
      std::cout << xs[j] << ",";      
    }
    std::cout << std::endl;;      
    delete xs;
  }
}

sep@linux:~/fh/prog3/examples/src> ./NewArray
0,1,2,3,4,5,6,7,8,9,
0,1,2,3,4,5,6,7,8,9,10,
0,1,2,3,4,5,6,7,8,9,10,11,
0,1,2,3,4,5,6,7,8,9,10,11,12,
0,1,2,3,4,5,6,7,8,9,10,11,12,13,
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,
sep@linux:~/fh/prog3/examples/src>

Reihungen als Parameter

#include <iostream>

int add(int xs [],int argc){
  int result=0;
  for (int i=0;i<argc;i++){
    result=result+xs[i];
  }
  return result;
}

int main(){
  int xs [] = {1,2,3,4};
  std::cout << add(xs,4) << std::endl;
}

#include <iostream>

int add(int xs [],int argc){
  int result=0;
  for (int i=0;i<argc;i++){
    result=result+xs[i];
  }
  return result;
}

int main(){
    int xs [] = {1,2,3,4};
    std::cout << add(xs) << std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ -c WrongArrayParameter.cpp
WrongArrayParameter.cpp: In function `int main()':
WrongArrayParameter.cpp:3: error: too few arguments to function `int add(int*,
   int)'
WrongArrayParameter.cpp:13: error: at this point in file
sep@linux:~/fh/prog3/examples/src>

#include <iostream>

int add(int xs [],int argc){
  int result=0;
  for (int i=0;i<argc;i++){
    result=result + *(xs+i);
  }
  return result;
}

int main(){
  int xs [] = {1,2,3,4};
  std::cout << add(xs,4) << std::endl;
}

Reihungen als Rückgabewert

#include <iostream>

int*  newArray(int length){
  int result [length];
  return result;
}

int main(){
   int* xs = newArray(5);

   for (int i=0;i<5;i++){
     std::cout << xs[i];
   }
   std::cout << std::endl;
}

WrongArrayReturn.cpp: In function `int* newArray(int)':
WrongArrayReturn.cpp:5: Warnung: address of local variable `result' returned
sep@linux:~/fh/prog3/examples/src>

sep@linux:~/fh/prog3/examples/src> ./WrongArrayReturn
1-1073745324-10737454321074404108134519424
sep@linux:~/fh/prog3/examples/src>

#include <iostream>

int*  newArray(int length){
    return new int[length];
}

int main(){
   int* xs = newArray(5);

   for (int i=0;i<5;i++){
     std::cout << xs[i];
   }
   std::cout << std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ -o ReturnArray ReturnArray.cpp
sep@linux:~/fh/prog3/examples/src> ./ReturnArray
00000
sep@linux:~/fh/prog3/examples/src>

C Strings als Reihungen von Zeichen

Beispiel:
Folgendes Programm legt eine Zeichenkette als Reihung an und betrachtet diese einmal über die Reihungsvariable und einmal über einen Zeiger auf das erste Element.

#include <iostream>

int main(){
  char xs [] = "hallo";
  char *ys = xs;
  ys[1] = 'e'; 
  std::cout << xs << std::endl;
  std::cout << ys << std::endl;
  xs[5] = '!';
  std::cout << xs << std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ -o CString CString.cpp
sep@linux:~/fh/prog3/examples/src> ./CString
hello
hello
hello!%/1?%/1#@ @@8%/1(@
sep@linux:~/fh/prog3/examples/src>

#include <iostream>

int main(){
  char hello[] = 
   { 'H', 'e', 'l', 'l', 'o', '\0' };
  std::cout << hello << std::endl;
}

#include <iostream>

int main(){
  char hello[] = 
   { 'H', 'e', 'l', 'l', 'o'};
  std::cout << hello << std::endl;
}

#include <iostream>

int main(){
  char hello [] = "hello world!";
  hello[5] ='\0';

  std::cout << hello << std::endl;
}

Kommandozeilenparameter

#include <iostream>

int main(int argc, char * argv []){  
  for (int i=0;i<argc;i++){
    std::string arg = argv[i];
    std::cout << arg << std::endl;
  }
}

sep@linux:~/fh/prog3/examples/bin> ./CommandLineOption hallo C -v gruss
./CommandLineOption
hallo
C
-v
gruss
sep@linux:~/fh/prog3/examples/bin>

Gleichheit auf Reihungen

#include <iostream>

bool arrayEq(int xs [],int xsLength, int ys [],int ysLength){
  if (xsLength!=ysLength) return false;
  for (int i=0;i<xsLength;i++){
    if (xs[i]!=ys[i]) return false;
  }
  return true;
}

std::string printBool(bool b){
  if (b) return "true"; else return "false";
}

int main(){
  int xs [] = {1,2,3,4};
  int ys [] = {1,2,3,4};
  int zs [] = {0,2,3,4};
  
  std::cout << printBool(xs==ys) << std::endl;
  std::cout << printBool(xs==zs) << std::endl;
  std::cout << printBool(arrayEq(xs,4,ys,4)) << std::endl;
  std::cout << printBool(arrayEq(xs,4,zs,4)) << std::endl;
}

sep@linux:~/fh/prog3/examples/bin> ./CEQArray
false
false
true
false
sep@linux:~/fh/prog3/examples/bin>

Mehrdimensionale Reihungen

class JTwoDimArray{
  public static void main(String [] _){
   int xys [][] = new int [5][12];
   for (int x=0;x<5;x=x+1){
     for (int y=0;y<12;y=y+1){
       xys[x][y]=x+y;
     }
   }

   for (int x=0;x<5;x=x+1){
    for (int y=0;y<12;y=y+1){
     System.out.println(xys[x][y]);
    }
   }
  }
}

#include <iostream>

int main(){
  int xys [5][12];
  for (int x=0;x<5;x=x+1){
    for (int y=0;y<12;y=y+1){
       xys[x][y]=x+y;
    }
  }

  for (int x=0;x<5;x=x+1){
    for (int y=0;y<12;y=y+1){
      std::cout << xys[x][y]<< std::endl;
     }
  }
}

int main(){
  int xys [][]
    = {{11,12,13,14,15}
      ,{21,22,23,24,25}
      ,{31,32,33,34,35}
      ,{41,42,43,44,45}
    };
}

sep@linux:~/fh/prog3/examples/src> g++ WrongTwoDimArray.cpp
WrongTwoDimArray.cpp: In function `int main()':
WrongTwoDimArray.cpp:3: error: declaration of `xys' as multidimensional array
   must have bounds for all dimensions except the first
WrongTwoDimArray.cpp:7: error: assignment (not initialization) in declaration
sep@linux:~/fh/prog3/examples/src>

#include <iostream>

int main(){
  int xys [][5]
    = {{11,12,13,14,15}
      ,{21,22,23,24,25}
      ,{31,32,33,34,35}
      ,{41,42,43,44,45}
    };

  for (int x=0;x<4;x=x+1){
    for (int y=0;y<5;y=y+1){
      std::cout << xys[x][y]<< std::endl;
     }
  }
}

Beispiel:
Folgendes Javaprogramm erzeugt eine zweidimensionale Reihung, deren erste innere Reihung drei und deren zweite innere Reihung 4 Elemente hat. Eine solche mehrdimensionale Reihung ist in C nicht möglich.

class DifferentDims {  
  public static void main(String [] _){
    int [] xs = {1,2,3};
    int [] ys = {4,5,6,7};
    int [][] xys = {xs,ys};

    for (int x=0;x<2;x=x+1){
      for (int y=0;y<xys[x].length;y=y+1){
        System.out.println(xys[x][y]);
      }
    }
  }
}

#include <iostream>

int main(){
  int xys [][5]
    = {{11,12,13,14,15}
      ,{21,22,23,24,25}
      ,{31,32,33,34,35}
      ,{41,42,43,44,45}
    };

  for (int x=0;x<4;x=x+1){
      std::cout << xys[x]<< std::endl;
  }
}

sep@linux:~/fh/prog3/examples/src> ./TwoDimArray3
0xbffff1b0
0xbffff1c4
0xbffff1d8
0xbffff1ec
sep@linux:~/fh/prog3/examples/src>

#include <iostream>

int main(){
  int xys [][5]
    = {{11,12,13,14,15}
      ,{21,22,23,24,25}
      ,{31,32,33,34,35}
      ,{41,42,43,44,45}
    };
  int *pXys = &xys[0][0];

  for (int x=0;x<20;x=x+1){
      std::cout << *(pXys+x)<< std::endl;
  }
}

#include <iostream>

int main(){
  int xys [][5]
    = {{11,12,13,14,15}
      ,{21,22,23,24,25}
      ,{31,32,33,34,35}
      ,{41,42,43,44,45}
    };

  for (int x=0;x<4;x=x+1){
    for (int y=0;y<5;y=y+1){
      std::cout << (x,y) << std::endl;
      std::cout << xys[x,y]<< std::endl;
     }
  }
}

sep@linux:~/fh/prog3/examples/src> ./NotTheIndexYouProbablyMean
0
0xbffff180
1
0xbffff194
2
0xbffff1a8
3
0xbffff1bc
4
0xbffff1d0
0
0xbffff180
1
0xbffff194
2
0xbffff1a8
3
0xbffff1bc
4
0xbffff1d0
0
0xbffff180
1
0xbffff194
2
0xbffff1a8
3
0xbffff1bc
4
0xbffff1d0
0
0xbffff180
1
0xbffff194
2
0xbffff1a8
3
0xbffff1bc
4
0xbffff1d0
sep@linux:~/fh/prog3/examples/src>

Funktionen höherer Ordnung für Reihungen

Beispiel:
Wir schreiben für Reihungen ganzer Zahlen die Funktion map, die jedes Element einer Reihung mit einer übergebenen Funktion umwandelt:

#include <iostream>

void map(int xs [],int l,int (*f) (int)){
  for (int i=0;i<l;i++){
    xs[i]=f(xs[i]);
  }
}

int add5(int x){return x+5;}
int square(int x){return x*x;}
int doubleX(int x){return 2*x;}

void printArray(int xs [],int l){
  std::cout<<"{";
  for (int i=0;i<l-1;i++){
    std::cout << xs[i]<<", ";
  }
  std::cout << xs[l-1] << "}"<<std::endl;
}

int main(){
  int xs [] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  map(xs,15,add5);
  printArray(xs,15);
  map(xs,15,square);
  printArray(xs,15);
  map(xs,15,doubleX);
  printArray(xs,15);
}

sep@linux:~/fh/prog3/examples/src> ./IntMap
{6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
{36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400}
{72, 98, 128, 162, 200, 242, 288, 338, 392, 450, 512, 578, 648, 722, 800}
sep@linux:~/fh/prog3/examples/src>

{\bf \alph{unteraufgabe})} Implementieren Sie eine Funktion
void bubbleSort(int xs [],int length ),
die Elemente mit dem Bubblesort-Algorithmus der Größe nach sortiert. Schreiben Sie ein paar Tests für Ihre Funktion.
{\bf \alph{unteraufgabe})} Schreiben Sie jetzt eine verallgemeinerte Sortierfunktion, in der die Sortierrelation als Parameter mitgegeben wird. Die Sortierfunktion soll also eine Funktion höherer Ordnung mit folgender Signatur sein:
void bubbleSortBy(int xs [],int length, bool (*smaller) (int,int) )

fold(xs,l,op,st) = op(... op(op(op(st,xs[0]),xs[1]),xs[2])...,xs[l-1])

fold({x₀,x₁,,...,x_l-1},l,op,st) = st op x₀ op x₁ op x₂ op ... op x_l-1

#include <iostream>

int add(int x,int y){return x+y;}
int mult(int x,int y){return x*y;}

int fold(int xs [],int length,int (*foldOp)(int,int),int startV);

int main(){
  int xs [] = {1,2,3,4,5};
  std::cout << fold(xs,5,add,0)<< std::endl;
  std::cout << fold(xs,5,mult,1)<< std::endl;
}

2.2.3  Produkte und Summen von Typen

class StringIntProduct{
  String typ1;
  int    typ2;
  public StringIntProduct(String e1, int e2){
    typ1=e1;
    typ2=e2;
  }
}

class StringIntSum {}

class StringTyp extends StringIntSum {
  StringTyp(String v){value=v;}
  String value;
}

class IntTyp extends StringIntSum {
  IntTyp(int v){value=v;}
  int value;
}

Typprodukt mit Strukturen

Beispiel:
Im folgenden Beispiel definieren wir eine Struktur zur Speicherung von Personendaten. Eine Instanz wird gebildet, auf der mehrere Test zur internen Speicherablage von Strukturen gemacht werden.

#include <string>
#include <iostream>

struct Person 
  {std::string name
  ;std::string vorname
  ;std::string strasse
  ;std::string stadt
  ;int plz
  ;int gebjahr
  ;int gebmonat
  ;int gebtag
  ;};

int main(){
  struct Person p1
    = {"Zabel", "Walther", "Hauptstrasse", "Ludwigshafen"
      , 65345, 1962, 3, 26};

  std::cout << p1.stadt << std::endl;

  std::cout << sizeof(p1) << std::endl;
  std::cout
   << &p1.name    << std::endl << &p1.vorname << std::endl
   << &p1.strasse << std::endl << &p1.stadt   << std::endl
   << &p1.plz     << std::endl << &p1.gebjahr << std::endl
   << &p1.gebmonat<< std::endl << &p1.gebtag  << std::endl;
}

sep@linux:~/fh/prog3/examples/src> ./PersonStruktur
Ludwigshafen
32
0xbffff140
0xbffff144
0xbffff148
0xbffff14c
0xbffff150
0xbffff154
0xbffff158
0xbffff15c
sep@linux:~/fh/prog3/examples/src>

Beispiel:
Wir definieren eine einfache Struktur, erzeugen eine Instanz und weisen diese einer zweiten Strukturvariablen zu:

#include <string>
#include <iostream>

struct S {std::string n1; std::string n2;};

int main(){
  struct S s1 = {"hallo","welt"};
  struct S s2 = s1;

  std::cout << s1.n1 << " " << s1.n2 << std::endl;
  std::cout << s2.n1 << " " << s2.n2 << std::endl;

  s2.n2 ="berlin";

  std::cout << s1.n1 << " " << s1.n2 << std::endl;
  std::cout << s2.n1 << " " << s2.n2 << std::endl;
}

sep@linux:~/fh/prog3/examples/src> c++ -o AssignStruct AssignStruct.cpp
sep@linux:~/fh/prog3/examples/src> ./AssignStruct
hallo welt
hallo welt
hallo welt
hallo berlin
sep@linux:~/fh/prog3/examples/src>

Beispiel:
Schreiben wir für eine einfache Struktur für Personen eine Funktion, die den Namen ändern soll. Diese funktioniert nicht, wenn wir die Struktur übergeben, sondern nur wenn wir einen Zeiger auf die Struktur übergeben.

#include <string>
#include <iostream>

struct Person 
  {std::string name
  ;std::string vorname
  ;};

void doNotChangeName(struct Person p,std::string n){
    p.name = n;
}

void changeNameWithPointer(struct Person * p,std::string n){
    (*p).name = n;
}

int main(){
  struct Person p1
    = {"Brecht", "Bertholt"};
  doNotChangeName(p1,"Schmidt");
  std::cout << p1.name << std::endl;

  changeNameWithPointer(&p1,"Schmidt");
  std::cout << p1.name << std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ -o PassStruct PassStruct.cpp
sep@linux:~/fh/prog3/examples/src> ./PassStruct
Brecht
Schmidt
sep@linux:~/fh/prog3/examples/src>

#include <string>
#include <iostream>
 
struct S1 {std::string n;std::string n2;std::string n3;};

struct S2 {std::string n;struct S1 s;};

int main (){
  S1 s1 = {"hello","wie","geht's"};
  S2 s2 = {"welt",s1};
  std::cout << s2.s.n << " " << s2.n << std::endl;

  std::cout << sizeof(s1) << std::endl;
  std::cout << sizeof(s2) << std::endl;
}

sep@linux:~/fh/prog3/examples/src> ./StructOfStruct
hello welt
12
16
sep@linux:~/fh/prog3/examples/src>

struct IntList {int head;IntList *tail;bool isEmpty;};
  
IntList *Cons(int hd,IntList* tl);
IntList *Empty();

int head(IntList *dieses);
IntList *tail(IntList *dieses);
bool isEmpty(IntList *dieses);

int length(IntList * dieses);

#include "IntList.h"

IntList *Cons(int hd,IntList* tl){
  IntList * result = new IntList;
  (*result).head=hd;
  (*result).tail=tl;
  (*result).isEmpty=false;
  return result;
}

IntList *Empty(){
  IntList * result = new IntList;
  (*result).isEmpty=true;
  return result;
}

int head(IntList *dieses){
  return (*dieses).head;
}
IntList *tail(IntList *dieses){
  return (*dieses).tail;
}
bool isEmpty(IntList *dieses){
  return (*dieses).isEmpty;
}

int length(IntList * dieses){
  if (isEmpty(dieses)) return 0;
  return 1+length((*dieses).tail);
}

#include <iostream>
#include "IntList.h"

int main(){
  IntList *xs = Cons(1,Cons(2,Cons(3,Cons(4,Empty()))));
  std::cout << length(tail(xs))<<std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ -c IntList.cpp
sep@linux:~/fh/prog3/examples/src> g++ -c TestIntList.cpp
sep@linux:~/fh/prog3/examples/src> g++ -o TestIntList IntList.o TestIntList.o
sep@linux:~/fh/prog3/examples/src> ./TestIntList
3
sep@linux:~/fh/prog3/examples/src>

enum bool {false,true};

struct IntList{
  int head;
  struct IntList* tail;
  enum bool empty;
};
  
struct IntList *Cons(int hd,struct IntList* tl);
struct IntList *Empty();

int head(struct IntList *dieses);
struct IntList *tail(struct IntList *dieses);
enum bool isEmpty(struct IntList *dieses);

int length(struct IntList* dieses);

#include "CIntList.h"
  
struct IntList *Cons(int hd,struct IntList* tl){
  struct IntList * result
     = (struct IntList*) malloc(sizeof(struct IntList));
  (*result).head=hd;
  (*result).tail=tl;
  (*result).empty=false;
  return result;
}

struct IntList *Empty(){
  struct IntList * result
    = (struct IntList*) malloc(sizeof(struct IntList));
  (*result).empty=true;
  return result;
}

int head(struct IntList *dieses){
  return (*dieses).head;
}
struct IntList *tail(struct IntList *dieses){
  return (*dieses).tail;
}

enum bool isEmpty(struct IntList *dieses){
  return (*dieses).empty;
}

int length(struct IntList* dieses){
  if (isEmpty(dieses)) return 0;
  return 1+length((*dieses).tail);
}

#include "CIntList.h"

int main(){
  struct IntList *xs
    = Cons(1,Cons(2,Cons(3,Cons(4,Empty()))));
  printf("%i\n",length(tail(xs)));
}

sep@linux:~/fh/prog3/examples/src> gcc -c TestCIntList.c
sep@linux:~/fh/prog3/examples/src> gcc -c CIntList.c
sep@linux:~/fh/prog3/examples/src> gcc -o TestCIntList TestCIntList.o CIntList.o
sep@linux:~/fh/prog3/examples/src> ./TestCIntList
3
sep@linux:~/fh/prog3/examples/src>

{\bf \alph{unteraufgabe})} int last(struct IntList * dieses)
{\bf \alph{unteraufgabe})} struct IntList * concat(struct IntList * xs,struct IntList * ys)
{\bf \alph{unteraufgabe})} int elementAt(struct IntList * dieses,int i)
{\bf \alph{unteraufgabe})} int fold(struct IntList * dieses,int start,int(*foldOp)(int,int))

Beispiel:
Ein kleines C Beispiel zum Gebrauch der Pfeilnotation.

struct Person 
  {char* name
  ;char* vorname
  ;};

void setName(struct Person* p,char* newName){
  p->name=newName;
}

int main(){
  struct Person p1 = {"Hotzenplotz", "Walther"};
  struct Person * pP1 = &p1;
  printf("%s\n",p1.name);
  printf("%s\n",(*pP1).name);
  printf("%s\n",pP1->name);
  setName(pP1,"Zabel");
  printf("%s\n",p1.name);
  printf("%s\n",(*pP1).name);
  printf("%s\n",pP1->name);
}

• Objektmethoden
• Vererbeung
• und late-binding

// pseudo class for persons
struct CPerson 
  {char* name
  ;char* vorname
  ;char* strasse
  ;char* stadt
  ;int plz
  ;char* (*getFullNameFunction)(struct CPerson*)
  ;};

//pseudo instance method for some this object 
char* getFullName(struct CPerson * this);

//constructor for CPerson
struct CPerson* newPerson 
  (char* n, char* v,char* str,char* st,int p);

// pseudo subclass of CPerson for students
struct CStudent 
  {struct CPerson super
  ;int matrNr;
  };

//constructor for CStudent
struct CStudent* newStudent
  (char* n, char* v,char* str,char* st,int p,int ma);

#include "CPerson.h"

int main(){
  //create a person object
  struct CPerson* p1
   = newPerson("Schmidt","Harald","studio449","koeln",54566);

  //create a student object, but store it in a Person variable
  struct CPerson* p2 
   = newStudent("Andrak","Manuel","studio449","koeln",54566
               ,565456);
 
  //print the full names of the two person objects
  printf("die erste Person ist: %s\n",getFullName(p1));
  printf("der zweite Person ist: %s\n",getFullName(p2));

  //make a cast of the second person to student
  printf("mit Matrikel-Nr.: %i\n",((struct CStudent*)p2)->matrNr);
}

#include "CPerson.h"
#include <string.h>
#include <stdlib.h>

char* getFullPersonName(struct CPerson* this){
  size_t nameLength = strlen (this->name);
  size_t vornameLength = strlen (this->vorname);
  char* result
   = malloc((nameLength + vornameLength+3) * sizeof(char));
  char* end = result; 
  end=(char*)stpcpy(end,this->name);  
  end=(char*)stpcpy(end,", ");  
  end=(char*)stpcpy(end,this->vorname);  
  return result;
}

char* getFullStudentName(struct CPerson* this){
  size_t nameLength = strlen (this->name);
  size_t vornameLength = strlen (this->vorname);
  char* result
   = malloc((nameLength + vornameLength+3) * sizeof(char));
  char* end = result; 
  end=(char*)stpcpy(end,this->vorname);  
  end=(char*)stpcpy(end," ");  
  end=(char*)stpcpy(end,this->name);  
  return result;
}

void initPerson(struct CPerson* result
               ,char* n, char* v,char* str,char* st,int p){
  result->name = n;
  result->vorname = v;
  result->strasse = str;
  result->stadt = st;
  result->plz = p;
  result->getFullNameFunction = &getFullPersonName;
}

struct CPerson* newPerson
   (char* n, char* v,char* str,char* st,int p){
  struct CPerson* result 
    = (struct CPerson*) malloc(sizeof(struct CPerson));
  initPerson(result, n,  v, str, st, p);
  return result;
}

struct CStudent* newStudent
   (char* n, char* v,char* str,char* st,int p,int ma){
  struct CStudent* result 
    = (struct CStudent*) malloc(sizeof(struct CStudent));
  initPerson(&(result->super), n,  v, str, st, p);

  (result->super).getFullNameFunction = &getFullStudentName;

  result->matrNr = ma;

  return result;
}

char* getFullName(struct CPerson * this){    
  return (*(this->getFullNameFunction))(this);
};

sep@linux:~/fh/prog3/examples/src> gcc -o TestCPerson TestCPerson.c CPerson.c
TestCPerson.c: In function `main':
TestCPerson.c:11: Warnung: initialization from incompatible pointer type
sep@linux:~/fh/prog3/examples/src> ./TestCPerson
die erste Person ist: Schmidt, Harald
der zweite Person ist: Manuel Andrak
mit Matrikel-Nr.: 565456
sep@linux:~/fh/prog3/examples/src>

Typsumme mit Unions

Beispiel:
Im folgenden kleinem Programm wird eine Typsumme definiert und beispielhaft in einer Hauptmethode benutzt.

#include <iostream>

union stringOrInt {int i;char *s;};

int main(){
  union stringOrInt sOrI;
  sOrI.s="hallo da draussen";
  std::cout << sOrI.s << std::endl;

  sOrI.i=42;
  std::cout << sOrI.i << std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ -o Union1 Union1.cpp
sep@linux:~/fh/prog3/examples/src> ./Union1
hallo da draussen
42
sep@linux:~/fh/prog3/examples/src>

Beispiel:
In diesem Beispiel benutzen wir den selben Summentypen wie im vorhergehenden Beispiel. Jetzt interpretieren wir aber jeweils die Daten auch als die andere Typalternative.

#include <iostream>

union stringOrInt {int i;char *s;};

int main(){
  union stringOrInt sOrI;
  sOrI.s="hallo da draussen";
  std::cout << sOrI.s << std::endl;
  std::cout << sOrI.i << std::endl;

  sOrI.i=42;
  std::cout << sOrI.i << std::endl;
  std::cout << sOrI.s << std::endl;
}

sep@linux:~/fh/prog3/examples/src> ./Union2
hallo da draussen
134514920
42
Speicherzugriffsfehler
sep@linux:~/fh/prog3/examples/src>

Beispiel:
In diesem Beispiel definieren wir eine Typsumme, die in einer Struktur eingebettet ist. Dazu definieren wir drei Typen: eine Aufzählung, eine Typsumme und eine Struktur.

#include <iostream>

enum TypeMarker {INT,STRING};
union stringOrInt {int i;char * s;};

struct strOrInt {TypeMarker type;union stringOrInt v;};

struct strOrInt forInt(int i){
  strOrInt result;
  result.type=INT;
  result.v.i=i;
  return result;
}

struct strOrInt forString(char * s){
  strOrInt result;
  result.type=STRING;
  result.v.s=s;
  return result;
}

char * toString(struct strOrInt si){
  char* result;
  if (si.type==INT){
    sprintf(result,"%d",si.v.i);
  }else if (si.type==STRING){
    result=si.v.s;
  }
  return result;
}

int main(){
  strOrInt test = forString("hallo da draussen");
  std::cout << toString(test)<<std::endl;
  test = forInt(42);
  std::cout << toString(test)<<std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ -o Union3 Union3.cpp
sep@linux:~/fh/prog3/examples/src> ./Union3
hallo da draussen
42
sep@linux:~/fh/prog3/examples/src>

#include <iostream>

union U1 {char a1 [15]; char a2 [200];};
union U2 {int a1; char a2 [16];};

int main(){
  U1 u1;
  U2 u2;
  std::cout << sizeof(u1) << std::endl;
  std::cout << sizeof(u2) << std::endl;
 }

sep@linux:~/fh/prog3/examples/src> ./Union4
200
16
sep@linux:~/fh/prog3/examples/src>

Chapter 3
Generische und Überladene Funktionen

3.1  Generische Funktionen

template <typename a>
a trace(a x);

#include <iostream>
#include "Trace.h"

template <typename a>
a trace(a x){
  std::cout << ">>>trace: " << x << std::endl;
  return x;
}

int main(){
  int x = 5 + trace(21*2);
  char *str = "hallo";
  trace(str);
  x = trace(6 + trace(18*2));
}

sep@linux:~/fh/prog3/examples/src> g++ -o Trace Trace.cpp
sep@linux:~/fh/prog3/examples/src> ./Trace
>>>trace: 42
>>>trace: hallo
>>>trace: 36
>>>trace: 42
sep@linux:~/fh/prog3/examples/src>

#include <iostream>
#include "Trace.h"

template <typename a>
a trace(a x){
  std::cout <<">>>trace: "<< x << std::endl;
  return x;
}

struct S {int x;char* s;};

int main(){
  S u = {42,"hallo"};
  u = trace(u);
}

sep@linux:~/fh/prog3/examples/src> g++ -c TraceWrongUse.cpp
TraceWrongUse.cpp: In function `a trace(a) [with a = S]':
TraceWrongUse.cpp:13:   instantiated from here
TraceWrongUse.cpp:6: error: no match for 'operator<<' in '
   std::operator<<(std::basic_ostream<char, _Traits>&, const char*) [with
   _Traits = std::char_traits<char>]((&std::cout), ">>>trace: ") << x'
/usr/include/g++/bits/ostream.tcc:63: error: candidates are:
   std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT,
   _Traits>::operator<<(std::basic_ostream<_CharT,
   _Traits>&(*)(std::basic_ostream<_CharT, _Traits>&)) [with _CharT = char,
   _Traits = std::char_traits<char>]
/usr/include/g++/bits/ostream.tcc:85: error:
   std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT,
   _Traits>::operator<<(std::basic_ios<_CharT,
   _Traits>&(*)(std::basic_ios<_
         .
         .
         .

sep@linux:~/fh/prog3/examples/src>

template <typename a, typename b, typename c>
c composition(c (* f2)(b),b (* f1)(a),a x);

3.1.1  Heterogene und homogene Umsetzung

template <typename a>
a trace(a x);

#include <iostream>
#include "T.h"

template <typename a>
a trace(a x){
  std::cout << ">>>trace: " << x << std::endl;
  return x;
}

#include "T.h"

int main(){
  trace(2*21);
}

ep@linux:~/fh/prog3/examples> cd src
sep@linux:~/fh/prog3/examples/src> g++ -c T.cpp
sep@linux:~/fh/prog3/examples/src> g++ -c UseT.cpp
sep@linux:~/fh/prog3/examples/src>

sep@linux:~/fh/prog3/examples/src> g++ -o UseT UseT.o T.o
UseT.o(.text+0x16): In function `main':
: undefined reference to `int trace<int>(int)'
collect2: ld returned 1 exit status
sep@linux:~/fh/prog3/examples/src>

3.1.2  Expizite Instanziierung des Typparameters

Beispiel:
In diesem Beispiel rufen wir zweimal die Funktion trace mit einer Zahlenkonstante auf. Einmal geben wir explizit an, daß es sich bei der der Konstante um eine int-Zahl handeln soll, einmal , daß es sich um eine Fließkommazahl handeln soll.

#include "T.cpp"

int main(){
  trace<float>(2*21656567);
  trace<int>(2*21656567);
}

sep@linux:~/fh/prog3/examples/src> ./ExplicitTypeParameter
>>>trace: 4.33131e+07
>>>trace: 43313134
sep@linux:~/fh/prog3/examples/src>

3.1.3  Generizität für Reihungen

#include <iostream>

template <typename a, typename b>
void map(a xs [],b ys [],int l,b (*f) (a)){
  for (int i=0;i<l;i++){
    ys[i]=f(xs[i]);
  }
}

template <typename a>
void printArray(a xs [],int l){
  std::cout<<"{";
  for (int i=0;i<l-1;i++){
    std::cout << xs[i]<<", ";
  }
  std::cout << xs[l-1] <<"}"<<std::endl;
}

int add5(int x){return x+5;}
char charAt2(std::string xs){return xs[2];}
std::string doubleString(std::string ys){return ys+ys;}

int main(){
  int xs [] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  int ys [15];
  map(xs,ys,15,&add5);
  printArray(ys,15);

  std::string us  []= {"hallo","jetzt","wirds","cool"};
  char vs [4];
  map(us,vs,4,&charAt2);
  printArray(vs,4);

  std::string ws [4];
  map(us,ws,4,&doubleString);
  printArray(ws,4);
}

sep@linux:~/fh/prog3/examples/bin> ./GenMap
{6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
{l, t, r, o}
{hallohallo, jetztjetzt, wirdswirds, coolcool}
sep@linux:~/fh/prog3/examples/bin>

3.2  Überladen von Funktionen

Beispiel:
Jetzt schreiben wir die trace Funktion nicht mit Hilfe einer Funktionsschablone, sondern durch Überladung.

#include <string>
#include <iostream>

struct Person 
  {std::string name
  ;std::string vorname
  ;};

Person trace(Person& p){
  std::cout << p.vorname << " " << p.name<< std::endl;
  return p;
}

int trace (int i){
  std::cout << i << std::endl;return i;
}

float trace (float i){
  std::cout << i << std::endl;return i;
}

std::string trace (std::string i){
  std::cout << i << std::endl;return i;
}

int main(){
  Person p1 = {"Zabel", "Walther"};
  Person p2 = trace(p1);
  trace (456456456);
  trace (425456455.0f);
  std::string s1 = "hallo";
  std::string s2 = trace (s1);
}

sep@linux:~/fh/prog3/examples/src> ./OverloadedTrace
Walther Zabel
456456456
4.25456e+08
hallo
sep@linux:~/fh/prog3/examples/src>

3.3  Standardparameter

Beispiel:
Im folgenden definieren wir eine Funktion, die zwei ganze Zahlen als Parameter erhält. Der zweite Parameter hat einen Standardwert von 40. Bei Aufruf der Funktion mit nur einem Parameter wird für den Parameter y der Standardwert benutzt.

#include <iostream>

int f(int x,int y=40){return x+y;}

int main(){
    std::cout << "f(1,2) = "<< f(1,2) << std::endl;
    std::cout << "f(2)   = "<< f(2) << std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ -o DefaultParameter DefaultParameter.cpp
sep@linux:~/fh/prog3/examples/src> ./DefaultParameter
f(1,2) = 3
f(2)   = 42
sep@linux:~/fh/prog3/examples/src>

Beispiel:
Jetzt simulieren wir, so wie wir es bereits aus Java gewohnt sind, Standardparameter durch eine überladene Funktionsdefinition.

#include <iostream>

int f(int x,int y){return x+y;}
int f(int x){return f(x,40);}

int main(){
    std::cout << "f(1,2) = "<< f(1,2) << std::endl;
    std::cout << "f(2)   = "<< f(2) << std::endl;
}

sep@linux:~> g++ -o OverloadedInsteadOfDefaults OverloadedInsteadOfDefaults.cpp
sep@linux:~> ./OverloadedInsteadOfDefaults
f(1,2) = 3
f(2)   = 42
sep@linux:~>

Chapter 4
Objektorientierte Programmierung in C++

• Objektmethoden
• Konstruktoren
• Vererbung
• späte Bindung
• Erreichbarkeiten

4.1  Klassen

4.1.1  Klassendeklaration

Beispiel:
Unsere erste C++ Klasse zur Darstellung von Personen:

#include <iostream>

class Person {
 public:
  std::string nachname;
  std::string vorname;
  std::string getFullName(){
    return vorname+" "+nachname;
  }
};

int main(){
  Person p1;
  p1.nachname="Zabel";
  p1.vorname="Walther";
  std::cout << p1.getFullName() << std::endl;
  Person p2 = p1;
  std::cout << p2.getFullName() << std::endl;
  p2.nachname = "Hotzenplotz";
  std::cout << p1.getFullName() << std::endl;
  std::cout << p2.getFullName() << std::endl;
  Person p3 = {"Shakespeare","William"};
  std::cout << p3.getFullName() << std::endl;
}

sep@linux:~/fh/prog3/examples/src> ./P1
Walther Zabel
Walther Zabel
Walther Zabel
Walther Hotzenplotz
William Shakespeare
sep@linux:~/fh/prog3/examples/src>

4.1.2  Header-Dateien für Klassen

#include <string>

class Person {

public:
  std::string nachname;
  std::string vorname;
  std::string getFullName();
};

#include "P2.h"

std::string Person::getFullName(){return vorname+" "+nachname;}

#include "P2.h"
#include <iostream>

int main(){
  Person p1;
  p1.nachname="Zabel";
  p1.vorname="Walther";
  std::cout << p1.getFullName() << std::endl;
  Person p2 = p1;
  std::cout << p2.getFullName() << std::endl;
  p2.nachname = "Hotzenplotz";
  std::cout << p1.getFullName() << std::endl;
  std::cout << p2.getFullName() << std::endl;
  Person p3 = {"Shakespeare","William"};
  std::cout << p3.getFullName() << std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ -c TesteP2.cpp
sep@linux:~/fh/prog3/examples/src> g++ -c P2.cpp
sep@linux:~/fh/prog3/examples/src> g++ -c TestP2.cpp 
sep@linux:~/fh/prog3/examples/src> g++ -o TestP2 P2.o TestP2.o
sep@linux:~/fh/prog3/examples/src> ./TestP2
Walther Zabel
Walther Zabel
Walther Zabel
Walther Hotzenplotz
William Shakespeare
sep@linux:~/fh/prog3/examples/src>

4.1.3  Konstruktoren

Beispiel:
Wir können jetzt eine Klasse Person schreiben, die so wie wir es aus Java gewohnt sind, einem Konstruktor hat, in dem alle relevanten Felder der Klasse explizit gesetzt werden:

#include <string>
#include <iostream>

class Person {

  private:
   std::string nachname;
   std::string vorname;
   std::string strasse;
   int hausnummer;
   int plz;
   std::string ort;

  public:
    Person(std::string nachname ,std::string vorname
          ,std::string strasse  ,int hausnummer
          ,int plz              ,std::string ort);

    std::string getFullName();
    std::string getAddress();
    void setStrasse(std::string strasse);
};

#include <string>
#include <iostream>
#include "Person.h"

Person::Person(std::string nachname,std::string vorname
              ,std::string strasse,int hausnummer
              ,int plz,std::string ort){
  this->nachname=nachname;
  this->vorname=vorname;
  this->strasse=strasse;
  this->hausnummer=hausnummer;
  this->plz=plz;
  this->ort=ort;
}

std::string Person::getFullName(){
  return vorname+" "+nachname;
}

std::string Person::getAddress(){
  char hausnr[20];
  sprintf(hausnr,"%d",hausnummer);

  char plznr[20];
  sprintf(plznr,"%d",plz);

  return strasse+" "+hausnr +"\n"+" "+plznr+ort;
}

void Person::setStrasse(std::string strasse){
  this->strasse = strasse;
}

#include "Person.h"
#include <iostream>

int main(){
  Person p1("Schmidt","Helmut","Brüderstrasse"
           ,82,20121,"Hamburg");
  Person p2("Kohl","Helmut","Saumagenstrasse"
           ,98,60121,"Ludwigshafen");

  std::cout << p1.getFullName() << std::endl
            << p1.getAddress()  << std::endl;
  std::cout << p2.getFullName() << std::endl 
            << p2.getAddress()  << std::endl;

  p1.setStrasse("Sonnenstrasse");
  std::cout << p1.getFullName() << std::endl 
            << p1.getAddress()  << std::endl;
}

#include "Person.h"

int main(){
  Person p;
}

sep@linux:~/fh/prog3/examples/src> g++ PersonKonstruktorError.cpp
PersonKonstruktorError.cpp: In function `int main()':
PersonKonstruktorError.cpp:4: error: no matching function for call to `Person::
   Person()'
Person.cpp:4: error: candidates are: Person::Person(const Person&)
Person.cpp:21: error:                 Person::Person(std::basic_string<char,
   std::char_traits<char>, std::allocator<char> >, std::basic_string<char,
   std::char_traits<char>, std::allocator<char> >, std::basic_string<char,
   std::char_traits<char>, std::allocator<char> >, int, int,
   std::basic_string<char, std::char_traits<char>, std::allocator<char> >)
sep@linux:~/fh/prog3/examples/src>

Konstruktion mit new

Beispiel:
Jetzt benutzen wir die Klasse Person, indem wir die Objekte über den Operator new erzeugen. Wir speichern das Ergebnis in Variablen des Zeigertyps Person*. Zum Benutzen der Eigenschaften dieses Zeigertyps müssen wir den Pfeiloperator bedienen und nicht wie zuvor den Punktoperator.

#include "Person.h"
#include <iostream>

int main(){
  Person* p1 = new Person("Schmidt","Helmut","Brüderstrasse"
                         ,82,20121,"Hamburg");
  Person* p2 = new Person("Kohl","Helmut","Saumagenstrasse"
                         ,98,60121,"Ludwigshafen");

  std::cout << p1->getFullName() << std::endl
            << p1->getAddress()  << std::endl;
  std::cout << p2->getFullName() << std::endl 
            << p2->getAddress()  << std::endl;

  p1->setStrasse("Sonnenstrasse");
  std::cout << p1->getFullName() << std::endl 
            << p1->getAddress() << std::endl;
}

Syntaktischer Zucker für Konstruktoren

Beispiel:
Den Konstruktor der Klasse Person hätten wir demnach auch wie folgt schreiben können:

#include <string>
#include "Person.h"

Person::Person(std::string nachname,std::string vorname
              ,std::string strasse,int hausnummer
              ,int plz,std::string ort):
   nachname(nachname),vorname(vorname),strasse(strasse)
  ,hausnummer(hausnummer),plz(plz),ort(ort){}

4.1.4  Destruktoren

#include <string>

class StringList {
  private:
    bool empty;
    std::string hd;
    StringList*  tl;

  public:
    StringList();
    StringList(std::string hd,StringList* tl);

    bool isEmpty();
    std::string head();
    StringList* tail();

    StringList* concat(StringList* other);
};

#include <string>
#include <iostream>
#include "StringList.h"

StringList::StringList():empty(true){};
StringList::StringList(std::string hd,StringList* tl):
   empty(false),hd(hd),tl(tl){} 
    
bool StringList::isEmpty(){return empty;}
std::string StringList::head(){return hd;}
StringList* StringList::tail(){return tl;}

StringList* StringList::concat(StringList* other){
  if (isEmpty()) return other;
  return new StringList(head(),tail()->concat(other));
}

#include <iostream>
#include "StringList.h"

int main(){
  StringList* xs = new StringList("friends"
                  ,new StringList("romans"
                  ,new StringList("contrymen"
                  ,new StringList())));

  StringList* ys = new StringList("lend"
                  ,new StringList("me"
                  ,new StringList("your"
                  ,new StringList("ears"
                  ,new StringList()))));
  
  StringList* zs = xs->concat(ys);

  delete xs;
  ys=zs;
  xs=zs;
}

void deleteList(StringList* xs){
  if (!xs->isEmpty()){
    deleteList(xs->tail());
  }
  delete xs;
}

Beispiel:
Jetzt ergänzen wir die Klasse StringList um eine Destruktor, der dafür sorgt, daß mit delete nicht nur der ersten Knoten einer Liste aus dem Speicher entfernt wird, sondern die komplette Liste.

#include <string>
#include <iostream>

class StringList {
  private:
    bool empty;
    std::string hd;
    StringList*  tl;

  public:
    ~StringList(){
      if (!isEmpty()) delete tl;
    }

    StringList(){
      empty= true; 
    }

    StringList(std::string hd,StringList* tl){
      empty= false; 
      this->hd=hd;
      this->tl=tl;
    }

    bool isEmpty(){return empty;}
    std::string head(){return hd;}
    StringList* tail(){return tl;}

    StringList* concat(StringList* other){
      if (isEmpty()) return other;
      return new StringList(head(),tail()->concat(other));
    }
};

int main(){
  StringList* xs = new StringList("friends"
                  ,new StringList("romans"
                  ,new StringList("contrymen"
                  ,new StringList())));

  StringList* ys = new StringList("lend"
                  ,new StringList("me"
                  ,new StringList("your"
                  ,new StringList("ears"
                  ,new StringList()))));
  
  StringList* zs = xs->concat(ys);

  delete xs;
  ys=zs;
  xs=zs;
}

Was soll ich löschen?

Wie macht Java das?

4.1.5  Konstantendeklarationen

Konstante Objektmethoden

#include <iostream>

class Const {
public:
  int i;

  void printValue() const {
    std::cout << i << std::endl;
  }
};

int main(){
  Const test;
  test.i=42;
  test.printValue();
}

#include <iostream>

class Const {
public:
  int i;
  void setValue(int j) const {
    i=j;
  }

  void printValue() const {
    setValue(42);
    std::cout << i << std::endl;
  }
};

sep@linux:~/fh/prog3/examples/src> g++ ConstThisError1.cpp
ConstThisError1.cpp: In member function `void Const::setValue(int) const':
ConstThisError1.cpp:7: error: assignment of data-member `Const::i' in read-only
   structure
sep@linux:~/fh/prog3/examples/src>

#include <iostream>

class Const {
public:
  int i;
  void setValue(int j) {
    i=j;
  }

  void printValue() const {
    setValue(42);
    std::cout << i << std::endl;
  }
};

sep@linux:~/fh/prog3/examples/src> g++ ConstThisError2.cpp
ConstThisError2.cpp: In member function `void Const::printValue() const':
ConstThisError2.cpp:11: error: passing `const Const' as `this' argument of `
   void Const::setValue(int)' discards qualifiers
sep@linux:~/fh/prog3/examples/src>

konstante Parameter

#include <iostream>
class Const {
  public:
    int i;
    void Const::printValue() const;
};

void doNotModify(const Const* c){
  std::cout << "in doNotModify" << std::endl;
} 

void Const::printValue() const {
  doNotModify(this);
  std::cout << i << std::endl;
}

int main(){
  Const c;
  c.i=42;
  c.printValue();
}

#include <iostream>
class Const {
public:
  int i;
  void Const::printValue() const;
};

void doNotModify(Const* c){
  std::cout << "in doNotModify" << std::endl;
} 

void Const::printValue() const {
  doNotModify(this);
  std::cout << i << std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ ConstParamError1.cpp
ConstParamError1.cpp: In member function `void Const::printValue() const':
ConstParamError1.cpp:13: error: invalid conversion from `const Const* const' to
   `Const*'
sep@linux:~/fh/prog3/examples/src>

#include <iostream>
class Const {
public:
  int i;
  void Const::printValue() const;
};

void doModify(Const* c){
  std::cout << "in doModify" << std::endl;
} 

int main(){
  const Const c();
  doModify(&c);
}

sep@linux:~/fh/prog3/examples/src> g++ ConstParamError2.cpp
ConstParamError2.cpp: In function `int main()':
ConstParamError2.cpp:14: error: cannot convert `const Const (*)()' to `Const*'
   for argument `1' to `void doModify(Const*)'
sep@linux:~/fh/prog3/examples/src>

public class Box <elementType> {
  public elementType contents;
  public  Box(elementType c) {contents = c;}
  
  public static void main(String [] _){
    final Box<Box<String>> bbs
	= new Box<Box<String>>(new Box<String>("hallo")); 
    
    //allowed
    bbs.contents.contents = "welt";

    //allowed
    bbs.contents = new Box<String>("world");

    //not allowed
    //bbs = new Box<Box<String>>(new Box<String>("hello")); 
  }
}

#include <string>

class BoxString{
  public:
    std::string contents;
    BoxString(std::string c) {contents = c;}
};

class BoxBoxString{
  public:
    BoxString* contents;
    BoxBoxString(BoxString* c) {contents = c;}
};

int main(){
  const BoxBoxString* pbbs
   = new BoxBoxString(new BoxString("hallo")); 
  const BoxBoxString bbs = *pbbs;

  //allowed
  pbbs->contents->contents = "welt";

  //not allowed
  //pbbs->contents = new BoxString("world");

  //allowed
  pbbs = new BoxBoxString(new BoxString("hello"));

  //allowed
  bbs.contents->contents = "welt";

  //not allowed
  //bbs.contents = new BoxString("world");

  //not allowed
  //bbs = *pbbs;
}

4.1.6  Ableiten

#include <string>
#include <iostream>

class Upper{};       

class Lower: public Upper{};

int main(){
  Upper* up = new Lower();
}

#include "Person.h"
#include <iostream>

class Student: public Person {

  private:
   int matrNr;

  public:
    Student(std::string nachname ,std::string vorname
          ,std::string strasse  ,int hausnummer
          ,int plz              ,std::string ort
          ,int mNr)
     :Person(nachname,vorname,strasse,hausnummer,plz,ort){
      this->matrNr = mNr;      
    }
};

int main(){
  Person* pP
   = new Student("Andrak","Manuel","schmidtstr"
                ,449,54654,"Koeln",723454);

  std::cout << pP->getFullName() << std::endl;
}

• virtuelle Methoden, für die das Prinzip der späten Bindung auf Referenzen realisiert ist.
• Methoden ohne späte Bindung.

#include <string>
#include <iostream>

  class Upper{
    public:
      std::string getDescription(){return "Obere Klasse";}
  };       

  class Lower: public Upper{
    public:
      std::string getDescription(){return "Untere Klasse";}
  };

int main(){
  Upper* upP = new Upper();
  Upper* loP = new Lower();

  Upper up = *upP;
  Upper lo = *loP;

  std::cout << "upP->getDecription()" 
            << upP->getDescription() << std::endl;
  std::cout << "loP->getDecription()" 
            << loP->getDescription() << std::endl;

  std::cout << "up.getDecription()" 
            << up.getDescription() << std::endl;
  std::cout << "lo.getDecription()" 
            << lo.getDescription() << std::endl;
}

sep@linux:~/fh/prog3/examples/src> ./UpperLowerTest
upP->getDecription()Obere Klasse
loP->getDecription()Obere Klasse
up.getDecription()Obere Klasse
lo.getDecription()Obere Klasse
sep@linux:~/fh/prog3/examples/src>

#include <string>
#include <iostream>

  class Upper{
    public:
      virtual std::string getDescription(){return "Obere Klasse";}
  };       

  class Lower : public Upper{
    public:
     std::string getDescription(){return "Untere Klasse";}
  };

#include <string>

int main(){
  Upper* upP = new Upper();
  Upper* loP = new Lower();

  Upper up = *upP;
  Upper lo = *loP;

  std::cout << "upP->getDecription()" 
            << upP->getDescription() << std::endl;
  std::cout << "loP->getDecription()" 
            << loP->getDescription() << std::endl;

  std::cout << "up.getDecription()" 
            << up.getDescription() << std::endl;
  std::cout << "lo.getDecription()" 
            << lo.getDescription() << std::endl;
}

sep@linux:~/fh/prog3/examples/src> ./UpperLowerTest2
upP->getDecription()Obere Klasse
loP->getDecription()Untere Klasse
up.getDecription()Obere Klasse
lo.getDecription()Obere Klasse
sep@linux:~/fh/prog3/examples/src>

4.1.7  protected

4.1.8  Überladen von Operatoren

Beispiel:
Wir definieren eine Klasse zur Darstellung komplexer Zahlen. Auf komplexen Zahlen definieren wir Addition, Multiplikation und die Norm, die durch Funktionsanwendungsklammern ausgedrückt werden soll.

#include <string>
#include <iostream>

class Complex {
  public:
    float im;
    float re;

    Complex(float re,float im);

    Complex operator+(const Complex& other)const;
    Complex operator*(const Complex& other)const;
    float operator()()const;

    std::string toString()const;
};

#include "Complex.h"
#include <sstream>

Complex::Complex(float re,float im){
  this->re=re;this->im=im;
}

Complex Complex::operator+(const Complex& other)const{
  return Complex(re+other.re,im+other.im);
}

Complex Complex::operator*(const Complex& other)const{
  return 
   Complex(re*other.re-im*other.im,re*other.im+im*other.re);
}

float Complex::operator()()const{
  return re*re+im*im;
}
std::string Complex::toString()const{
  std::string result="";
  std::stringstream ss;
  ss << re;
  ss >> result;
  result=result+"+";
  ss << im;
  ss >> result;
  result=result+"i";
  return result;
}

#include "Complex.cpp"    
  
int main(){
  Complex c1(31,40);
  Complex c2(0.5,2);
  std::cout << (c1+c2).toString() << std::endl;
  std::cout << (c1*c2).toString() << std::endl;
  std::cout << c2() << std::endl;
}

#include <string>

class StringLi {
  private:
    std::string hd;
    const StringLi* tl;
    const bool empty;

  public: 
    StringLi(std::string hd,const StringLi* tl);
    StringLi();
    virtual ~StringLi();

    bool isEmpty()const;
    std::string head()const;
    const StringLi* tail()const;
 
    StringLi* clone()const;

    const StringLi* operator+(const StringLi* other) const;

    std::string toString()const;
};

#include <string>
#include "StringLi.h"

StringLi::StringLi(std::string h,const StringLi* t):empty(false){
  this->hd=h;
  this->tl=t;
}

StringLi::StringLi():empty(true){}

StringLi::~StringLi(){
  if (!isEmpty()) delete tl;
}

bool StringLi::isEmpty()const{return empty;}
std::string StringLi::head()const{return hd;}    
const StringLi* StringLi::tail()const{return tl;}
 
StringLi* StringLi::clone()const{
  if (isEmpty()) return new StringLi();
  return new StringLi(head(),tail()->clone());
}

const StringLi* StringLi::operator+(const StringLi* other) const{
  if (isEmpty()) return other->clone();
  return new StringLi(head(),(*tail())+other);
}

std::string StringLi::toString()const{
  if (isEmpty()) return "()";
  std::string result="["+head();
  for (const StringLi* it=this->tail()
      ; !it->isEmpty();it=it->tail()){
    result=result+","+it->head();
  }
  return result+"]";
}

#include <iostream>
#include "StringLi.h"

int main(){
  const StringLi* xs
    = new StringLi("friends",
      new StringLi("romans",
      new StringLi("contrymen",
      new StringLi())));


  const StringLi* ys 
   = new StringLi("lend",
     new StringLi("me",
     new StringLi("your",
     new StringLi("ears",
     new StringLi()))));

  const StringLi* zs = *xs+ys;
  delete xs;
  delete ys;

  std::cout << zs->toString() << std::endl;
}

sep@linux:~/fh/prog3/examples/src> g++ -o StringLiTest StringLi.cpp StringLiTest.cpp
sep@linux:~/fh/prog3/examples/src> ./StringLiTest
[friends,romans,contrymen,lend,me,your,ears]
sep@linux:~/fh/prog3/examples/src>

• const std::string operator[](const int i) const; soll das i-te Element zurückgeben.
• const StringLi* operator-(const int i) const; soll eine neue Liste erzeugen, indem von der Liste die ersten i Elemente weggelassen werden.
• const bool operator<(const StringLi* other) const; soll die beiden Listen bezüglich ihrer Länge vergleichen.
• const bool operator==(const StringLi* other) const; soll die Gleichheit auf Listen implementieren.

4.1.9  Generische Formularklassen

#include <string>

class BoxString{
  public:
    std::string contents;
    BoxString(std::string c) {contents = c;}
};

class BoxInt{
  public:
    int contents;
    BoxInt(int c) {contents = c;}
};

#include <string>

template <class elementType>
class Box{
  public:
    elementType contents;
    Box(elementType c) {contents = c;}
};

#include <string>
#include <iostream>
#include "Box.h"

int main(){
  const Box<std::string>* bs = new Box<std::string>("hallo"); 
  const Box<int>* bi = new Box<int>(42); 
  const Box<Box<std::string>*>* bbs
    = new Box<Box<std::string>*>(new Box<std::string>("hallo")); 

  std::string s = bs -> contents;
  int i = bi -> contents;
  std::string s2= bbs -> contents->contents;

  std::cout << bs -> contents << std::endl;
  std::cout << bi -> contents << std::endl;
  std::cout << bbs -> contents->contents << std::endl;
}

#include <string>
#include "Box.h"

template <class fstType,class sndType>
class Pair: public Box<fstType>{
  public:
    sndType snd;
    Pair(fstType c,sndType snd):Box<fstType>(c),snd(snd) {}

    std::string toString(){
	return "("+contents+","+snd+")"; 
    }
};

#include "Pair.h"
#include <iostream>
#include <string>

int main(){
  Pair<std::string,int> p("hallo",42);
  std::cout << p.contents << std::endl;
  std::cout << p.snd << std::endl;
}

#include "Pair.h"

template <class fstType>
class UniPair: public Pair<fstType,fstType>{
  public:
    UniPair(fstType c,fstType snd):Pair<fstType,fstType>(c,snd) {}
    void swap(){fstType tmp=contents;contents=snd;snd=tmp;}
};

#include "UniPair.h"
#include <iostream>
#include <string>

int main(){
  UniPair<std::string> p("welt","hallo");
  p.swap();
  std::cout << p.contents << std::endl;
  std::cout << p.snd << std::endl;
}

Generische Listen

#include <string>
#include <sstream>

template <typename X>
bool equals(X x,X y){return x==y;}

std::string callToString(std::string x ){return x;}
std::string callToString(int x ){

  std::stringstream ss;
  std::string result;

  ss << x;
  ss >> result;

  return result;
}

template <typename X>
std::string callToString(X* x ){return x->toString();}

template <class A>
class Li {
  private:
    A hd;
    const Li<A>* tl;
    const bool empty;

  public: 
    Li(A hd,const Li<A>* tl):empty(false){
      this->hd=hd;
      this->tl=tl;
    }

    Li():empty(true){}


    bool isEmpty()const{return empty;}
    A head()const{return hd;}    
    const Li<A>* tail()const{return tl;}

    virtual ~Li(){
      if (!isEmpty()) delete tl;
    }

    Li<A>* clone()const{
      if (isEmpty()) return new Li<A>();
      return new Li<A>(head(),tail()->clone());
    }

    const Li<A>* operator+(const Li<A>* other) const{
      if (isEmpty()) return other->clone();
      return new Li<A>(head(),(*tail())+other);
    }

    int size() const {
      if (isEmpty()) return 0;
      return 1+tail()->size();
    }

    bool contains(A el, bool (*eq)(A,A))const{
      if (isEmpty())return false;
      if (eq(head(),el)) return true;
      return tail()->contains(el,eq);
    }

    bool contains(A el)const{
      return contains(el,equals);
    }

    template <typename B>
    Li<B>* map(B(*f)(A))const{
      if (isEmpty()) return new Li<B>();
      return new Li<B>(f(head()),tail()->map(f));
    }

    std::string toString(){
      if (isEmpty()) return "[]";
      std::string result="["+(callToString(this->head()));
      for (const Li<A>* it=this->tail()
          ; !it->isEmpty();it=it->tail()){
        result=result+","+(callToString(it->head()));
      }
      return result+"]";
    }
};

#include "Li.h"
#include "UniPair.h"
#include <iostream>
#include <string>

int callSize(std::string s){return s.size();}

std::string getContents(UniPair<std::string>* p){
 return p->contents;
}

int main(){
  Li<std::string>* xs
    = new Li<std::string>("Schimmelpfennig",
      new Li<std::string>("Moliere",
      new Li<std::string>("Shakespeare",
      new Li<std::string>("Bernhard",
      new Li<std::string>("Brecht",
      new Li<std::string>("Salhi",
      new Li<std::string>("Achternbusch",
      new Li<std::string>("Horvath",
      new Li<std::string>("Sophokles",
      new Li<std::string>("Calderon",
      new Li<std::string>()))))))))));

  std::cout << xs->toString() << std::endl; 
  std::cout << xs->contains("Brecht") << std::endl; 
  std::cout << xs->contains("Zabel") << std::endl; 

  Li<int>* is = xs->map(callSize);
  delete xs;

  std::cout << is->toString() << std::endl; 
  delete is;

  Li<UniPair<std::string>* >* ys =
  new Li<UniPair<std::string>* >(new UniPair<std::string>("A","1")
 ,new Li<UniPair<std::string>* >(new UniPair<std::string>("B","2")
 ,new Li<UniPair<std::string>* >(new UniPair<std::string>("C","3")
 ,new Li<UniPair<std::string>* >())));
 
  std::cout << ys->toString() << std::endl; 

  xs=ys->map(getContents);
  std::cout << xs->toString() << std::endl; 
}

sep@linux:~/fh/prog3/examples/src> ./TestLi
[Schimmelpfennig,Moliere,Shakespeare,Bernhard,Brecht,Salhi,Achternbusch,Horvath,Sophokles,Calderon]
1
0
[15,7,11,8,6,5,12,7,9,8]
[(A,1),(B,2),(C,3)]
[A,B,C]
sep@linux:~/fh/prog3/examples/src>

{\bf \alph{unteraufgabe})}
Schreiben Sie eine Klasse, die eine Hashmenge realisiert. Ihre Klasse soll der folgenden Kopfdatei entsprechend Funktionalität bereitstellen
HashSet
#include "Li.h"

template <class elementType>
class HashSet {
  protected:
    int capacity;
    int (*hashFunction)(elementType);
    Li<elementType>* hashArray [];
  
  public:
    HashSet(int c, int (*hashF)(elementType));
    virtual ~HashSet();
    void add(elementType el);

    bool contains(elementType el);    
    std::string toString();
};

{\bf \alph{unteraufgabe})} Schreiben Sie Testfälle und betrachten Sie, wie gut in diesen Tests die Elemente gestreut liegen.

4.1.10  Closures, Funktionsobjekte und Schönfinkeleien

Closures

template <class A>
class Closure {

  private:
    A value;

  public: 
    Closure <A> (A a) {
      this->value=a; 
    };

    Closure <A>(){}

    virtual  A operator()() { 
      return value;
    };
};

#include "Closure.h"
#include <iostream>

int main(){
   Closure<int> f1 = Closure<int>(42);
   std::cout << f1() << std::endl;   
}

#include "Closure.h"
#include <iostream>

template <class aT,class rT> 
class ApplyFun : public Closure<rT> {

  private:
    rT (*f)(aT); 
    aT arg;

    rT result;
    bool resultIsEvaluated;

  public: 
    ApplyFun <aT,rT> (rT(*f)(aT),aT a) {
      this->f=f; 
      this->arg=a;
      resultIsEvaluated=false;
    };

    ApplyFun <aT,rT> () {resultIsEvaluated=false;}

    virtual  rT operator()() { 
      if (!resultIsEvaluated){
        resultIsEvaluated = true;
        result=f(arg);
      }
      return result;
    };
};

• wir können ausdrücken, daß wir eine Funktion auf ein Argument zwar gerne aufrufen wollen, aber nicht sofort, sondern erst bei späteren Bedarf.
• der closure arbeitet mit einem Ergebnisspeicher. Wurde das Ergenis einmal ausgerechnet, so wird bei einem späteren Aufruf des Funktionsoperators das bereits errechnete Ergebnis benutzt und nicht nochmal ausgerechnet.

#include "ApplyFun.h"
#include "Li.h"
#include <iostream>
#include <string>

int add1(int x){std::cout << "add1" << std::endl;return x+1;}
int add2(int x){std::cout << "add2" << std::endl;return x+2;}
int add3(int x){std::cout << "add3" << std::endl;return x+3;}
int add4(int x){std::cout << "add4" << std::endl;return x+4;}
int getSize(std::string xs){return xs.length();}

int main(){
  Closure<int>* c1 = new ApplyFun<int,int>(add1,41);
  Closure<int>* c2 = new ApplyFun<int,int>(add2,40);
  Closure<int>* c3 = new ApplyFun<int,int>(add3,39);
  Closure<int>* c4 = new ApplyFun<int,int>(add4,38);

  std::cout << (*c2)() << std::endl;  

  Li<Closure<int>* >* xs = 
      new Li<Closure<int>* >(c1,
      new Li<Closure<int>* >(c2,
      new Li<Closure<int>* >(c3,
      new Li<Closure<int>* >(c4,
      new Li<Closure<int>* >()))));

  std::cout << xs->size() << std::endl;

  std::cout << (*(xs->tail()->tail()->head()))() << std::endl;  
  delete xs;

  Closure<int>*  c5
    = new ApplyFun<std::string,int>(getSize,"witzelbritz");
  std::cout << (*c5)() << std::endl;  
}

sep@linux:~/fh/prog3/examples/src> ./TestClosure
add2
42
4
add3
42
11
sep@linux:~/fh/prog3/examples/src>

#include "ApplyFun.h"
#include <iostream>

template <class A>
class LazyList {
  private:
    A hd;

    Closure<LazyList<A>*>* tl;
    const bool empty;

  public: 
    LazyList(A hd, Closure<LazyList<A>*>* tl):empty(false){
      this->hd=hd;
      this->tl=tl;
    }

    LazyList(A hd,LazyList<A>* t):empty(false){
      this->hd=hd;
      this->tl= new Closure<LazyList<A> >(t);
    }

    LazyList():empty(true){}

    bool isEmpty()const{return empty;}
    A head()const{return hd;}

    LazyList<A>* tail(){
      return (*tl)();
    }
};

#include "LazyList.h"
#include <iostream>

LazyList<int> *  from(int fr){
  Closure<LazyList<int>* >* tl 
   = new ApplyFun<int,LazyList<int>*>(from,fr+1);
  return new LazyList<int>(fr,tl);
}

int main(){
  LazyList<int>* xs = from(2);  
  for (int i=0;i<200000;i=i+1){
    LazyList<int>* ys = xs->tail();  
    std::cout << xs->head() << std::endl;
    delete xs;
    xs = ys;
  }
}

{\bf \alph{unteraufgabe})} Schreiben Sie eine generische Funktion:

template <typename A>
LazyList<A>* repeat(A x)

die eine Liste erzeugt, in der unendlich oft Wert x wiederholt wird.
{\bf \alph{unteraufgabe})} Schreiben Sie eine Funktion, die eine unendliche Liste von Pseudozufallszahlen erzeugt. Benutzen sie hierzu folgende Formel:
z_n+1 = (91 * z_n + 1) mod 347

Funktionsobjekte

template <class aT, class rT> 
class Lambda { 
  private:
    rT (*f)(aT); 

  public: 
    Lambda <aT,rT> (rT(*_f)(aT)){
      this->f=_f; 
    }; 

    Lambda <aT,rT> (){}

    virtual  rT operator()(aT arg) { 
      f(arg);
    };
};

#include "Lambda.h"
#include <iostream>

int add5(int x) {return x+5;}

int main(){
  Lambda<int,int> f1(add5);
  std::cout << add5(37) << std::endl;  
  std::cout << f1(37)   << std::endl;  
}

Currying

#include <iostream>
#include "Lambda.h"

template <class a,class b,class c>
class Curry : public Lambda<a,c>{

  public:
    b i;
    a (*f)(b x,c y);

    Curry(a(*f)(b x, c y),b i):i(i),f(f){}

    virtual a operator()(c y){ return f(i,y);}
};

int add(int x,int y){return x+y;}

int main(){
  Lambda<int,int>* add5 = new Curry<int,int,int>(add,5);
  int i = (*add5)(37);
  std::cout << i << std::endl;
}

drawRedRect = curry(drawRect,red);
drawRedSquare = curry(drawRedRect,3,3);

drawRedSquare(42,80);
drawRedSquare(17,4);
drawRedSquare(08,15);
drawRedSquare(47,11);

4.2  Die Standard Template Library

4.2.1  ein kleines Beispiel

Anwendung auf Reihungen

#include <algorithm>
#include <iostream>

void doppel(int& x){x=2*x;}

int main(){
  int  ar[3] = {17,28,21};
  std::for_each(ar,ar+3,doppel);
   
  for (int i= 0;i<3;i=i+1){
    std::cout << ar[i] << std::endl;
  }
}

Anwendung auf Vektoren

#include <vector>
#include <algorithm>
#include <iostream>

void doppel(int& x){x=2*x;}

int main(){
  std::vector<int> v = std::vector<int>(3);
  v[0] = 17; v[1]=28; v[2] = 21;
  std::for_each(v.begin(),v.begin()+3,doppel);
   
  for (int i= 0;i<3;i=i+1){
      std::cout << v[i] << std::endl;
  }
}

4.2.2  Konzepte

template <class InputIterator, class UnaryFunction>
UnaryFunction for_each
 (InputIterator first, InputIterator last, UnaryFunction f);

4.2.3  Iteratoren

Triviale Iteratorn

• ein parameterloser Standardkonstruktor, es muß also möglich sein eine Variable ohne explizite Initialisierung zu erzeugen: X x;
• die Dereferenzierung muß überladen sein, also *x muß für Elemente diesen Typs möglich sein.
• Zuweisung an die dereferenzierte Stelle, also der Ausdruck: *x = t.
• Dereferenzierter Zugriff auf Attribute, also die Pfeiloperation muß zur Verfügung stehen: x->m.

InputIterator

Beispiel:
Wir schreiben eine generische Funktion, die ermöglicht das größte Element eines Iterationsbereichs zu bestimmen.

#include <iostream>
#include <string>

template <typename InputIterator,typename Element>
Element* maximum(InputIterator begin,InputIterator end){
  Element* result = begin; 
  for (InputIterator it = begin+1;it<end;it++){
    if ((*result) < (*it)){ result=it;}
  } 
  return result;
}

int main(){
  int  ar[3] = {17,28,21};
  std::cout << * (maximum<int*,int>(ar,ar+3)) << std::endl;

  std::string  sr[3] = {"shakespeare","calderon","moliere"};
  std::cout << *(maximum<std::string*,std::string>(sr,sr+3)) 
            << std::endl;
}

4.2.4  Behälterklassen

Sequenzen

• sie können dynamische beliebig lang wachsen
• die gespeicherten Elemente haben eine Reihenfolge und können über einen Index angesprochen werden.

• vector: ermöglicht Elementzugriff über den Index in konstanter Zeit, Einfügen und Löschen am Ende der Sequenz in konstanter Zeit, Löschen und Einfügen an beliebigen Indexstellen in linearer Zeit. Diese Klasse entspricht am ehesten der Klasse java.util.ArrayList aus Java.
• deque: ähnlich zu vector erlaubt aber auch Einfügen und Löschen am Anfang der Sequenz mit konstanten Zeitaufwand.
• list: eine vorwärts und rückwärts verlinkte Liste
• slist: einfach verkettete Liste, ähnlich, wie wir sie selbst geschrieben haben.
• bit_vector: sehr spezialisierter Vektor, in dem nur ein Bit pro Element zur Verfügung steht. Damit als speichereffiziente Lösung für eine Sequenz von bool'schen Werten hervorragend geeignet.

Beispiel:
Folgendes kleine Programm zeigt den einfachen Umgang mit Sequenzklassen. Man beachte, daß die eigentlichen Typen der Iteratoren oft unbekannt sind. Wir können über diese abstrahieren, indem wir eine generische Funktion für die Iteration schreiben, die wir ohne konkrete Angabe der Typparameter aufrufen.

#include <vector>
#include <list>
#include <string>
#include <iostream>

template <typename Iterator>
void doPrint(Iterator begin,Iterator end){
  std::cout << "[";
  for (Iterator it = begin;it!=end;){
    std::cout << *it;  
    it++;    
    if (it != end) std::cout << ",";
  }
  std::cout << "]"<<std::endl;
}

int main (){
  std::string words [] ={ "the","world","is","my","oyster"};
  std::vector<std::string> sv;
  std::list<std::string> sl;
  std::cout << sv.capacity() << std::endl;

  for (int i=0;i<5;i++){
    sv.insert(sv.end(),words[i]);
    sl.insert(sl.end(),words[i]);
  }
  std::cout << sv.capacity() << std::endl;

  doPrint(sv.begin(),sv.end());
  sl.reverse();
  doPrint(sl.begin(),sl.end());
}

Mengen und Abbildungen

• set: Mengen mit nur einfachen vorkommen von Elementen.
• map:
• multiset:
• multimap:

Beispiel:
Folgendes Programm zeigt einen rudimentären Umgang mit Abbildungen. Eine Abbildung von Namen nach Adressen wird definiert. Interessant ist die Überladung des Operators [] für Abbildungen.

#include <map>
#include <string>
#include <iostream>

class Address {

  public:
    std::string strasse;
    int hausnummer;
    Address(){}
    Address(std::string strasse,int hasunummer)
        :strasse(strasse),hausnummer(hausnummer){}
};
      

int main(){
  std::map<std::string, Address,std::less<std::string> > 
    addressBook;
  addressBook.insert(
   std::pair<std::string,Address>
    ("Hoffmann",Address("Gendarmenmarkt",42)));
  addressBook.insert(
   std::pair<std::string,Address>
    ("Schmidt",Address("Bertholt-Brecht-Platz",1)));

  std::cout << addressBook["Hoffmann"].strasse << std::endl;

  addressBook["Tierse"] = Address("Pariser Platz",1);

  std::cout << addressBook["Tierse"].strasse << std::endl;
  std::cout << addressBook["Andrak"].strasse << std::endl;
}

• der Typ des Suchschlüssels
• der Typ des assoziierten Wertes
• der Typ der Kleinerrelation auf dem Schlüssel

Arbeiten mit String

Beispiel:
Folgendes kleine Programm demonstriert einen sehr rudimentären Umgang mit Strings.

#include <string>
#include <iostream>

using namespace std;

template <typename t>
bool isPallindrome(t w){
  t w2 = w;
  reverse(w2.begin(),w2.end());
  return w==w2;
}

int main(){
  cout << isPallindrome<string>("rentner")  << endl;
  cout << isPallindrome<string>("pensioner")<< endl;
  cout << isPallindrome<string>("koblbok")  << endl;
  cout << isPallindrome<string>("alexander")<< endl;
  cout << isPallindrome<string>("stets")    << endl;
  cout << isPallindrome<string>
                   ("ein neger mit gazellezag tim regen nie")
            << endl;
}

4.2.5  Algorithmen

Funktionsobjekte

Beispiel:
Folgendes Programm demonstriert Currying in der STL mit der Funktion bind1st.

#include <functional>
#include <iostream>

int main(){
  std::cout <<bind1st(std::plus<int>(),17)(25) <<std::endl;
}

Beispiel:
Folgendes Programm demonstriert die Benutzung der Klasse plus, die ein Funktionsobjekt für die Addition darstellt in Zusammenhang mit einer Funktion höherer Ordnung. Mit der STL-Funktion transform werden die Elemente zweier Reihungen paarweise addiert.

#include <algorithm>
#include <functional>
#include <iostream>

using namespace std;

void print (int a){cout << a <<",";}

int main(){
  int xs [] = {1,2,3,4,5};
  int ys [] = {6,7,8,9,10};
  int zs [5];
  transform(xs,xs+5,ys,zs,plus<int>());
  for_each(zs,zs+5,print);
  cout << endl;
}

Beispiel:
Selbstredend bietet die STL auch Funktionen zum Sortieren von Behälterobjekten an. Die Sortiereigenschaft kann dabei als Funktionsobjekt übergeben werden. Im folgenden Programm wird nach verschiedenen Eigenschaften sortiert.

#include <vector>
#include <list>
#include <string>
#include <iostream>

class ShorterString{
  public:
    bool operator()(std::string s1,std::string s2){
      return s1.length()<s2.length();
    }
};

bool reverseOrder(std::string s1,std::string s2){
  reverse(s1.begin(),s1.end());
  reverse(s2.begin(),s2.end());
  return s1<s2;
}

void print(std::string p){
  std::cout << p << ","; 
}

template <typename Iterator>
void printSequence(Iterator begin,Iterator end){
  if (begin==end) {
    std::cout << "[]" << std::endl;return;
  }
  std::cout << "["; 
  for_each(begin,end-1,print);
  std::cout << *(end-1) << "]"<<std::endl; 
}

int main (){
  int l = 8;
  std::string words []
   ={"rasiert","schweinelende","passiert","legende"
    ,"schwestern","verlustiert","gestern","stern"};

  std::sort(words,words+l,ShorterString());
  printSequence(words,words+l);

  std::sort(words,words+l,reverseOrder);
  printSequence(words,words+l);

  std::sort(words,words+l);
  printSequence(words,words+l);
}

sep@linux:~/fh/prog3/examples/src> g++ -o SortTest SortTest.cpp
sep@linux:~/fh/prog3/examples/src> ./SortTest
[stern,rasiert,legende,gestern,passiert,schwestern,verlustiert,schweinelende]
[legende,schweinelende,stern,gestern,schwestern,rasiert,passiert,verlustiert]
[gestern,legende,passiert,rasiert,schweinelende,schwestern,stern,verlustiert]
sep@linux:~/fh/prog3/examples/src>

{\bf \alph{unteraufgabe})} Implementieren Sie jetzt die Funktion fold zur Benutzung für allgemeine Behälterklassen im STL Stil entsprechend der Signatur:
STLFold
template <typename Iterator,typename BinFun,typename EType>
EType fold(Iterator begin,Iterator end,BinFun f,EType start);

{\bf \alph{unteraufgabe})} Testen Sie Ihre Implementierung mit folgendem Programm:
STLFoldTest
#include <vector>
#include <string>
#include <functional>
#include <iostream>
#include "STLFold.h"

int addLength(int x,std::string s){return x+s.length();}

std::string addWithSpace(std::string x,std::string y){
    return x+" "+y;
}

int main(){
  int xs []={1,2,3,4,5};
  int result;
  result = fold(xs,xs+5,std::plus<int>(),0);
  std::cout << result << std::endl;
  result = fold(xs,xs+5,std::multiplies<int>(),1);
  std::cout << result << std::endl;

  std::vector<std::string> ys;
  ys.insert(ys.end(),std::string("friends"));
  ys.insert(ys.end(),std::string("romans"));
  ys.insert(ys.end(),"contrymen");
  result = fold(ys.begin(),ys.end(),addLength,0);
  std::cout << result << std::endl;

  std::string erg
    = fold(ys.begin(),ys.end()
          ,std::plus<std::string>(),std::string(""));
  std::cout << erg << std::endl;

  erg=fold(ys.begin(),ys.end(),addWithSpace,std::string(""));
  std::cout << erg << std::endl;
}

{\bf \alph{unteraufgabe})} Schreiben Sie weitere eigene Tests.

4.3  Ausnahmen

• es gibt keine gesonderte Ausnahmeklassen. Alles kann geworfen werden, sogar Strukturen, Zeiger oder primitive Typen.
• Funktionen brauchen und können nicht deklarieren, welche Ausnahmen bei ihrem Aufruf geworfen werden. Es gibt keine throws-Klausel.
• Es gibt kein finally.

Beispiel:

#include <string>
#include <iostream>

int fac(int x){
  if (x<0) {
    std::string msg = "negative Zahl in Fakultaet";
    throw msg;
  } 
  if (x==0) return 1;
  return x*fac(x-1);
}


int main(){
  try{
    std::cout << fac(5) << std::endl;
    std::cout << fac(-5) << std::endl;
  }catch (std::string s){
    std::cout << s << std::endl;
  }
}

4.4  Namensräume

Beispiel:
Im folgenden Programm können einige der Konzepte der Namensräume in C++ nachvollzogen werden:

#include <iostream>

using namespace std;

namespace paket1 {
  void drucke() { cout << "paket1" << endl;
  }
}

namespace paket2 {
  void drucke() { cout << "paket2" << endl;
  }
  namespace paket3{
    void drucke() { cout << "paket3" << endl;
    }
  }
}

int main(){
  {
    using namespace paket2::paket3;
    paket2::drucke();    
    drucke();    
    paket1::drucke();
  }    
  {
    using namespace paket2;
    drucke();    
    paket3::drucke();    
    paket1::drucke();    
  }
  {
    using namespace paket1;
    paket2::drucke();    
    paket2::paket3::drucke();    
    drucke();
  }    
}

Chapter 5
Graphik und GUI Programmierung

5.1  3 dimensionale Graphiken mit OpenGL

5.1.1  Eine Zustandsmaschine

5.1.2  Eine kleine GUI Bibliothek: GLUT

Beispiel:
In diesem kleinen Beispiel wird ein Fenster geöffnet, dessen Zeichenfunktion lediglich den Fensterhintergrund mit einer definierten Löschfarbe löscht.

#include <GL/glut.h>

void display(void){
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glClear(GL_COLOR_BUFFER_BIT);
  glFlush();
}

int main (int argc, char **argv){
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB);
  glutCreateWindow("Hello Window");
  glutDisplayFunc(display);
  glutMainLoop();
}

5.1.3  Vertexes und Figuren

#include <GL/glut.h>
void moin(int argc, char **argv,int shape);

#include "SomePoints.h"
int shape=GL_POINTS;

void points(){
   glVertex3f(0.2,-0.4,0);
   glVertex3f(0.46,-0.26,0);
   glVertex3f(0.6,0,0);
   glVertex3f(0.6,0.2,0);
   glVertex3f(0.46,0.46,0);
   glVertex3f(0.2,0.6,0);
   glVertex3f(0.0,0.6,0);
   glVertex3f(-0.26,0.46,0);
   glVertex3f(-0.4,0.2,0);
   glVertex3f(-0.4,0,0);
   glVertex3f(-0.26,-0.26,0);
   glVertex3f(0,-0.4,0);
}

void pointsAsShape(){
  glClear(GL_COLOR_BUFFER_BIT );
  glColor3f (0.0, 0.0, 0.0); 
  glBegin(shape); 
    points();
  glEnd();
  glFlush();
}

void moin(int argc, char **argv,int s){
  shape=s;
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB);
  glutCreateWindow("Hello");
  glClearColor(1.0, 1.0, 1.0, 1.0);
  glutDisplayFunc(pointsAsShape);
  glutMainLoop();
}

• GL_POINTS nur als individuelle einzelne Punkte
• GL_LINES paarweise werden Linien verunden
• GL_LINE_STRIP ein Linienzug
• GL_LINE_LOOP ein geschlossener Linienzug. Der letzte Vertex wird wieder mit dem ersten verbunden.
• GL_TRIANGLES Tripel werden als Dreiecke verbunden.
• GL_TRIANGLE_STRIP zwei Dreiecke teilen sich einen Punkt.
• GL_TRIANGLE_FAN Ein Fächer von Dreiecke, die alle einen Punkt gemeinsam haben.
• GL_QUADS je vier Punkte als Vierecke verbunden.
• GL_QUAD_STRIP Ein Zug von miteinander verbundenen Vierecken.
• GL_POLYGON einfache konvexe Polygone.

#include "SomePoints.h"
int main (int argc, char **argv){moin(argc,argv,GL_POINTS);}

#include "SomePoints.h"
int main (int argc, char **argv){moin(argc,argv,GL_LINES);}

#include "SomePoints.h"
int main (int argc, char **argv){moin(argc,argv,GL_LINE_STRIP);}

#include "SomePoints.h"
int main (int argc, char **argv){moin(argc,argv,GL_LINE_LOOP);}

#include "SomePoints.h"
int main (int argc, char **argv){moin(argc,argv,GL_TRIANGLES);}

#include "SomePoints.h"
int main (int argc, char **as){moin(argc,as,GL_TRIANGLE_STRIP);}

#include "SomePoints.h"
int main (int argc, char **argv){moin(argc,argv,GL_TRIANGLE_FAN);}

#include "SomePoints.h"
int main (int argc, char **argv){moin(argc,argv,GL_QUADS);}

#include "SomePoints.h"
int main (int argc, char **argv){moin(argc,argv,GL_QUAD_STRIP);}

#include "SomePoints.h"
int main (int argc, char **argv){moin(argc,argv,GL_POLYGON);}

Beispiel:
Das folgende Programm zeichnet einen Funktionsgraphen:

#include <GL/glut.h>

float (*f) (float);
float square(float x) {return 3*x*x*x;};

void display(void){
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glClear(GL_COLOR_BUFFER_BIT);

  const int steps =100;
  const float step = 2/(float)100;
  glBegin(GL_LINE_STRIP);
  for (int i = 0; i < steps; i=i+1){
    const float x = -1+i*step;
    const float y = f(x);
    glVertex2f(x,y);
  }
  glEnd();
  glFlush();
}

int main (int argc, char **argv){
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB);
  glutCreateWindow("Function Graph Window");
  f = square;
  glutDisplayFunc(display);
  glutMainLoop();
}

Figure 5.2: Der Graph einer Funktion.

5.1.4  Nah und Fern

5.1.5  Vordefinierte Figuren

• Sphere: eine Kugel.
• Cube: ein Würfel.
• Torus: ein runder Ring (Donut).
• Icosahedron: Körper mit 16 dreieckigen Flächen.
• Octahedron: Körper mit 8 dreieckigen Flächen.
• Tetrahedron: Körper mit 4 dreieckigen Flächen.
• Dodecahedron: Körper mit 12 dreieckigen Flächen. ¹³
• Cone: ein Kegel.
• Teapot: eine Teekanne.

Beispiel:
In diesem Beispiel wird eine Kugel definiert.

#include <GL/glut.h>

void display(void){
  glClear(GL_COLOR_BUFFER_BIT );
  glColor3f (1.0, 0.0, 0.0); 
  glutSolidSphere(0.8,10,10);
  glFlush();
}

int main (int argc, char **argv){
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB);
  glutCreateWindow("Hello Cube");
  glClearColor(1.0, 1.0, 1.0, 1.0);
  glutDisplayFunc(display);
  glutMainLoop();
}

5.1.6  Bei Licht betrachtet

#include <GL/glut.h>
int moin (int argc, char **argv,void(*display)(),char* title);

#include "RenderShape.h"

void (*shapeFun)();

void display(){
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  shapeFun();
  glFlush();
} 

int moin (int argc, char **argv,void(*shape)(),char* title){
  shapeFun=shape;
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH);

  glutCreateWindow(title);

  GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; 
  GLfloat mat_shininess[] = { 50.0 }; 
  GLfloat light_position[] = { 1.0, 1.0, -2.5, 0.0 }; 

  glShadeModel (GL_SMOOTH); 

  glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); 
  glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); 
  glLightfv(GL_LIGHT0, GL_POSITION, light_position); 


  glEnable(GL_LIGHTING); 
  glEnable(GL_LIGHT0); 
  glEnable(GL_DEPTH_TEST);

  glClearColor(1.0, 0,0,0);
  glutDisplayFunc(display);
  glutMainLoop();
}

#include "RenderShape.h"
void f(){glutWireSphere(1,10,10); }
int main (int argc,char **argv){moin(argc,argv,f,"WireSphere");}

#include "RenderShape.h"
void f(){glutSolidSphere(1,10,10); }
int main (int argc,char **argv){moin(argc,argv,f,"SolidSphere");}

#include "RenderShape.h"
void f(){glutWireCube(1); }
int main (int argc,char **argv){moin(argc,argv,f,"WireCube");}

#include "RenderShape.h"
void f(){glutSolidCube(1); }
int main (int argc,char **argv){moin(argc,argv,f,"SolidCube");}

#include "RenderShape.h"
void f(){glutWireTorus(0.4,0.6,10,30); }
int main (int argc,char **argv){moin(argc,argv,f,"WireTorus");}

#include "RenderShape.h"
void f(){glutSolidTorus(0.4,0.6,10,30); }
int main (int argc,char **argv){moin(argc,argv,f,"SolidTorus");}

#include "RenderShape.h"
void f(){glutWireIcosahedron(); }
int main (int ac,char **av){moin(ac,av,f,"WireIcosahedron");}

#include "RenderShape.h"
void f(){glutSolidIcosahedron(); }
int main (int ac,char **av){moin(ac,av,f,"SolidIcosahedron");}

#include "RenderShape.h"
void f(){glutWireOctahedron(); }
int main (int ac,char **av){moin(ac,av,f,"WireOctahedron");}

#include "RenderShape.h"
void f(){glutSolidOctahedron(); }
int main (int ac,char **av){moin(ac,av,f,"SolidOctahedron");}

#include "RenderShape.h"
void f(){glutWireTetrahedron(); }
int main (int ac,char **av){moin(ac,av,f,"WireTetrahedron");}

#include "RenderShape.h"
void f(){glutSolidTetrahedron(); }
int main (int ac, char **av){moin(ac,av,f,"SolidTetrahedron");}

#include "RenderShape.h"
void f(){glutWireDodecahedron(); }
int main (int ac,char **av){moin(ac,av,f,"WireDodecahedron");}

#include "RenderShape.h"
void f(){glutSolidDodecahedron(); }
int main (int ac,char **av){moin(ac,av,f,"SolidDodecahedron");}

#include "RenderShape.h"
void f(){glutWireCone(0.3,0.8,20,25); }
int main (int ac,char **av){moin(ac,av,f,"WireCone");}

#include "RenderShape.h"
void f(){glutSolidCone(0.3,0.8,20,25); }
int main (int ac,char **av){moin(ac,av,f,"SolidCone");}

#include "RenderShape.h"
void f(){glutWireTeapot(0.6); }
int main (int ac,char **av){moin(ac,av,f,"WireTeapot");}

#include "RenderShape.h"
void f(){glutSolidTeapot(0.6);}
int main (int ac,char **av){moin(ac,av,f,"SolidTeapot");}

5.1.7  Transformationen

5.1.8  GLUT Tastatureingabe

Beispiel:

#include <GL/glut.h>

void display(void);
void keyboard(unsigned char, int, int);
void resize(int, int);
void drawcube(int, int, void (*color) ());

int main (int argc, char **argv){
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutInitWindowSize(600, 600);
  glutInitWindowPosition(40, 40);
  glutCreateWindow("The Cube World");
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glEnable(GL_DEPTH_TEST);
  glutDisplayFunc(display);
  glutKeyboardFunc(keyboard);
  glutReshapeFunc(resize);  
  glutMainLoop();
}

void red()  {glColor3f(1.0,0.0,0.0);}
void blue() {glColor3f(0.0,1.0,0.0);}
void green(){glColor3f(0.0,0.0,1.0);}
void grey() {glColor3f(0.8, 0.8, 0.8);}

void drawcube(int x_offset, int z_offset, void (*color)()){
  color();
  glPushMatrix();
    glTranslatef(x_offset,0.0,z_offset);
    glutSolidCube(10);
  glPopMatrix();
}

void display(void){
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  /* draw the floor */
  glPushMatrix();
    glTranslatef(0,-5,20);
    glScalef(30,0.1,30);
    drawcube(0, 0, grey);
  glPopMatrix();

  /* draw 12 cubes with different colors */
  drawcube(75, 57, red);
  drawcube(-65, -12, green);
  drawcube(50, -50, red);
  drawcube(-56, 17, blue);
  drawcube(67, 12, green);
  drawcube(-87, 32, red);
  drawcube(-26, 75, blue);
  drawcube(57, 82, green);
  drawcube(-3, 12, red);
  drawcube(46, 35, blue);
  drawcube(37, -2, green);

  glutSwapBuffers();
}

void keyboard(unsigned char key, int _, int __){
  switch (key){
    case 'a': case 'A': glTranslatef(5.0, 0.0, 0.0); break;
    case 'd': case 'D': glTranslatef(-5.0, 0.0, 0.0);break;
    case 'w': case 'W': glTranslatef(0.0, 0.0, 5.0); break;
    case 's': case 'S': glTranslatef(0.0, 0.0, -5.0);break;
  }
  display();
}

void resize(int width, int height){
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(45.0, width / height, 1.0, 400.0);
  glTranslatef(0.0, -5.0, -150.0);
  glMatrixMode(GL_MODELVIEW);
}

Figure 5.5: Dreidimensionale Klötzchenwelt.

5.1.9  Beispiel: Tux der Pinguin

#include <GL/glut.h>
#include <math.h>

float zPos = -1;

void display();
void keyboard(unsigned char, int, int);
void resize(int, int);

int main (int argc, char **argv){
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutCreateWindow("Tux");
  glClearColor(1.0, 0.0, 0.0, 0.0);

  glEnable(GL_LIGHTING); 
  glEnable(GL_NORMALIZE);
  glEnable(GL_DEPTH_TEST);

  GLfloat lights[] = { 1, 1, 1, 1 }; 
  GLfloat light_position[] = { 1, 0.4, 0.8, 1 }; 
  glLightfv(GL_LIGHT0, GL_POSITION, light_position); 

  glLightfv(GL_LIGHT0, GL_AMBIENT, lights); 
  glLightfv(GL_LIGHT0, GL_DIFFUSE, lights); 
  glLightfv(GL_LIGHT0, GL_SPECULAR, lights);
  glEnable(GL_LIGHT0); 

  glutDisplayFunc(display);
  glutKeyboardFunc(keyboard);
  glutReshapeFunc(resize);  
  glutMainLoop();
}

void keyboard(unsigned char key, int _, int __){
  switch (key){
    case '+': zPos=zPos+0.1;break;
    case '-': zPos=zPos-0.1;break;
  }
  display();
}

void resize(int w, int h){
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  float near   = 0.001;
  float    far    = 40;
  float    fov    = 90;
  float    ang    = (fov*3.14)/(360);
  float    top    = near / ( cos(ang) / sin(ang) );
  float    aspect = w/h;
  float    right = top*aspect;
  glFrustum(-right, right, -top, top, near, far);
  glMatrixMode(GL_MODELVIEW);
}

void sphere(float r, float xs, float ys,float  zs){
  glScalef(xs, ys, zs);
  glutSolidSphere(r,100,100);
}

void rotateZ(float a){glRotatef(a,0,0,1);}
void rotateY(float a){glRotatef(a,0,1,0);}
void rotateX(float a){glRotatef(a,1,0,0);}

void crMat(float rd,float gd,float bd
          ,float rs,float gs,float bs,float exp){
  float diffuse [] ={rd, gd, bd,  1.0};
  glMaterialfv(GL_FRONT,GL_DIFFUSE, diffuse);
  glMaterialfv(GL_FRONT,GL_AMBIENT, diffuse);
  float specular [] ={rs, gs, bs,  1.0};
  glMaterialfv(GL_FRONT,GL_SPECULAR, specular);
  float shine [] ={exp};
  glMaterialfv(GL_FRONT,GL_SHININESS,shine);
}

void whitePenguin() {
  crMat(0.58, 0.58, 0.58, 0.2, 0.2, 0.2, 50.0);
}
void blackPenguin() {crMat(0.1, 0.1, 0.1,0.5, 0.5, 0.5, 20.0);}
void beakColour()   {crMat(0.64, 0.54, 0.06,0.4, 0.4, 0.4, 5);}
void nostrilColour(){
  crMat(0.48039, 0.318627, 0.033725,0.0,0.0,0.0, 1);
}
void irisColour()   {crMat(0.01, 0.01, 0.01,0.4, 0.4, 0.4, 90.0);}

void makeBody(){
  glPushMatrix();
    blackPenguin();
    sphere(1, 0.95, 1.0, 0.8);
  glPopMatrix();
  glPushMatrix();
    whitePenguin();
    glTranslatef( 0, 0, 0.17);
    sphere(1, 0.8, 0.9, 0.7);
  glPopMatrix();
}

void createTorso(){
  glPushMatrix();
    glScalef( 0.9, 0.9, 0.9);
    makeBody();
  glPopMatrix();
}


void leftHand(){
  glPushMatrix();
    glTranslatef( -0.24, 0, 0);
    rotateZ(20);
    rotateX(90);
    blackPenguin();
    sphere( 0.5, 0.12, 0.05, 0.12);
  glPopMatrix();
}


void leftForeArm(){
  glPushMatrix();
    glTranslatef(-0.23, 0, 0);
    rotateZ( 20);
    rotateX( 90);
    leftHand();
    blackPenguin();
    sphere( 0.66, 0.3, 0.07, 0.15);
  glPopMatrix();
}

void rightForeArm(){leftForeArm();}

void leftArm(){
  glPushMatrix();
    rotateY(180);
    glTranslatef( -0.56, 0.3, 0);
    rotateZ( 45);
    rotateX( 90);
    leftForeArm();
    blackPenguin();
    sphere( 0.66, 0.34, 0.1, 0.2);
  glPopMatrix();
}

void rightArm(){
  glPushMatrix();
    glTranslatef(-0.56, 0.3, 0);
    rotateZ( 45);
    rotateX(-90);
    rightForeArm();
    blackPenguin();
    sphere( 0.66, 0.34, 0.1, 0.2);
  glPopMatrix();
}

void createShoulders(){
  glPushMatrix();
    glTranslatef( 0, 0.4, 0.05);
    leftArm();
    rightArm();
    glScalef( 0.72, 0.72, 0.72);
    makeBody();
  glPopMatrix();
}


void createBeak(){
  glPushMatrix();
    glTranslatef( 0,-0.205, 0.3);
    rotateX(10);
    beakColour();
    sphere( 0.8, 0.23, 0.12, 0.4);
  glPopMatrix();
  glPushMatrix();
    beakColour();
    glTranslatef( 0, -0.23, 0.3);
    rotateX( 10);
    sphere( 0.66, 0.21, 0.17, 0.38);
  glPopMatrix();
}


void leftIris(){
  glPushMatrix();
    glTranslatef( 0.12,-0.045, 0.4);
    rotateY( 18);
    rotateZ( 5);
    rotateX( 5);
    irisColour();
    sphere( 0.66, 0.055, 0.07, 0.03);
  glPopMatrix();
}


void rightIris(){
  glPushMatrix();
    glTranslatef( -0.12,-0.045, 0.4);
    rotateY( -18);
    rotateZ( -5);
    rotateX( 5);
    irisColour();
    sphere( 0.66, 0.055, 0.07, 0.03);
  glPopMatrix();
}

void leftEye(){
  glPushMatrix();
    glTranslatef( 0.13,-0.03, 0.38);
    rotateY( 18);
    rotateZ( 5);
    rotateX( 5);
    whitePenguin();
    sphere( 0.66, 0.1, 0.13, 0.03);
  glPopMatrix();
}

void rightEye(){
  glPushMatrix();
    glTranslatef( -0.13,-0.03, 0.38);
    rotateY( -18);
    rotateZ( -5);
    rotateX( 5);
    whitePenguin();
    sphere( 0.66, 0.1, 0.13, 0.03);
  glPopMatrix();
}

void createEyes(){
  leftEye();
  leftIris();
  rightEye();
  rightIris();
}

void createHead(){
  glPushMatrix();
    glTranslatef( 0, 0.3, 0.07);
    createBeak();
    createEyes();
    rotateY( 90);
    blackPenguin();
    sphere( 1, 0.42, 0.5, 0.42);
  glPopMatrix();
}

void createNeck(){
  glPushMatrix();
    glTranslatef( 0, 0.9, 0.07);
    createHead();
    rotateY(90);
    blackPenguin();
    sphere( 0.8, 0.45, 0.5, 0.45);
    glTranslatef( 0, -0.08, 0.35);
    whitePenguin();
    sphere( 0.66, 0.8, 0.9, 0.7);
  glPopMatrix();
}

void footBase(){
  glPushMatrix();
    sphere( 0.66, 0.25, 0.08, 0.18);
  glPopMatrix();
}


void toe1(){
  glPushMatrix();
    glTranslatef(-0.07, 0, 0.1);
    rotateY( 30);
    sphere(0.66, 0.27, 0.07, 0.11);
  glPopMatrix();
}

void toe2(){
  glPushMatrix();
    glTranslatef(-0.07, 0, -0.1);
    rotateY (-30);
    sphere( 0.66,  0.27, 0.07, 0.11);
  glPopMatrix();
}

void toe3(){
  glPushMatrix();
    glTranslatef(-0.08, 0, 0);
    sphere( 0.66,  0.27, 0.07, 0.10);
  glPopMatrix();
}

void foot(){
  glPushMatrix();
    glScalef(  1.1, 1.0, 1.3); 
    beakColour();
    footBase();
    toe1();
    toe2();
    toe3();
  glPopMatrix();
}

void rightFoot(){
  glPushMatrix();
    glTranslatef( 0,-0.09, 0);
    rotateY( 180);
    foot();
  glPopMatrix();
}

void leftFoot(){
  glPushMatrix();
    glTranslatef( 0,-0.09, 0);
    rotateY( 100);
    foot();
  glPopMatrix();
}


void leftCalf(){
  glPushMatrix();
    glTranslatef( 0,-0.21, 0);
    rotateY( 90);
    leftFoot();
    beakColour();
    sphere( 0.5, 0.06, 0.18, 0.06);
  glPopMatrix();
}

void rightCalf(){
  glPushMatrix();
    glTranslatef( 0,-0.21, 0);
    rightFoot();
    beakColour();
    sphere( 0.5, 0.06, 0.18, 0.06);
  glPopMatrix();
}

void hipBall(){
  glPushMatrix();
    blackPenguin();
    sphere( 0.5, 0.09, 0.18, 0.09);
  glPopMatrix();
}

void leftTigh(){
  glPushMatrix();
    rotateY( 180);
    glTranslatef(-0.28,-0.8, 0);
    rotateY( 110);
    hipBall();
    leftCalf();

    rotateY (-110);
    glTranslatef( 0,-0.1, 0);
    beakColour();
    sphere( 0.5, 0.07, 0.3, 0.07);
  glPopMatrix();
}

void rightTigh(){
  glPushMatrix();
    glTranslatef(-0.28,-0.8, 0);
    rotateY( -110);
    hipBall();
    rightCalf();

    glTranslatef( 0,-0.1, 0);
    beakColour();
    sphere( 0.5, 0.07, 0.3, 0.07);
  glPopMatrix();
}

void createTail(){
  glPushMatrix();
    glTranslatef( 0,-0.4,-0.5);
    rotateX (-60);
    glTranslatef( 0, 0.15, 0);
    blackPenguin();
    sphere( 0.5, 0.2, 0.3, 0.1);
  glPopMatrix();
}

void tux(){
  glPushMatrix();
    glScalef( 0.35, 0.35, 0.35);
    rotateY (-180);
    createTorso();
    createShoulders();
    createNeck();
    leftTigh();
    rightTigh();
    createTail();
  glPopMatrix();
}

void display(){
  glLoadIdentity();
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  gluLookAt(0,0,zPos,0,0,0,0,1,0);
  tux();
  glutSwapBuffers();
}

Appendix A
Gtk für C++ Beispielprogramme

A.1  Ein einfacher Zähler

A.1.1  Die Kopfdatei

#include <gtkmm/button.h>
#include <gtkmm/window.h>
#include <gtkmm/label.h>
#include <gtkmm/box.h>

class Counter : public Gtk::Window{

public:
  Counter();
  virtual ~Counter();

protected:
  virtual void on_button_clicked();

  Gtk::Button button;
  Gtk::Label  label;
  Gtk::HBox  box;
  int counter;
};

A.1.2  Implementierung

#include "Counter.h"
#include <iostream>
#include <sstream>
#include <string>

Counter::Counter()
:  button("Drück Mich")
  ,label("0"){
  counter=0;
  set_border_width(10);

  button
    .signal_clicked()
    .connect(SigC::slot
              (*this, &Counter::on_button_clicked));

  box.add(button);
  box.add(label);
  add(box);

  button.show();
  label.show();
  box.show();
}

Counter::~Counter(){}

void Counter::on_button_clicked(){
  std::stringstream ss;
  std::string zahl;
  counter=counter+1;
  ss << counter;
  ss >> zahl;
  label.set_text(zahl);
}

A.1.3  Beispielaufruf

#include <gtkmm/main.h>
#include "Counter.h"

int main (int argc, char *args[]){
  Gtk::Main kit(argc,args);

  Counter counter;
  Gtk::Main::run(counter); 
}

A.2  Einfaches Zeichnen

#include <gtkmm/drawingarea.h>
#include <gdkmm/colormap.h>
#include <gdkmm/window.h>
#include <gtkmm/box.h>
#include <gtkmm/window.h>
#include <gtkmm/main.h>

#include <cmath>

const double DEG2RAD = 3.1415928 / 180.0;

class StrichKreis : public Gtk::DrawingArea
{
public:
  StrichKreis(int r);
  ~StrichKreis();

protected:
  virtual void on_realize();
  virtual bool on_expose_event(GdkEventExpose* event);

  Glib::RefPtr<Gdk::GC> gc_;
  Gdk::Color black_, white_;
};

StrichKreis::StrichKreis(int r){
  Glib::RefPtr<Gdk::Colormap> colormap = get_default_colormap();
  black_ = Gdk::Color("black");
  white_ = Gdk::Color("white");
  
  colormap->alloc_color(black_);
  colormap->alloc_color(white_);
  set_size_request(r, r);
}

StrichKreis::~StrichKreis(){}

void StrichKreis::on_realize(){
  // We need to call the base on_realize()
  Gtk::DrawingArea::on_realize();

  // Now we can allocate any additional resources we need
  Glib::RefPtr<Gdk::Window> window = get_window();
  gc_ = Gdk::GC::create(window);
  window->set_background(black_);
}

bool StrichKreis::on_expose_event(GdkEventExpose*){
  Glib::RefPtr<Gdk::Window> window = get_window();

  // window geometry: x, y, width, height, depth
  int winx, winy, winw, winh, wind;
  window->get_geometry(winx, winy, winw, winh, wind);

  window->clear();
  int radius = winw/2;
  if (winh<winw) radius=winh/2;

  gc_->set_foreground(white_);

  for (int i = 0; i<=360; i=i+1){  
      int x1,y1,x2,y2;
      x1=winw/2;
      y1=winh/2;
      x2 = x1 + (int) (radius * cos(DEG2RAD * i));
      y2 = y1 + (int) (radius * sin(DEG2RAD * i));
      window->draw_line(gc_, x1,y1,x2,y2 );
  } 

  return true;
}


int main(int argc, char** argv){
  Gtk::Main main_instance (argc, argv);
  Gtk::Window* window = new Gtk::Window();
  Gtk::HBox* m_box0 = new Gtk::HBox(false,0);

  StrichKreis* kreis1 = new StrichKreis(400);
  StrichKreis* kreis2 = new StrichKreis(180);
  StrichKreis* kreis3 = new StrichKreis(50);
  StrichKreis* kreis4 = new StrichKreis(100);
  StrichKreis* kreis5 = new StrichKreis(20);

  m_box0->pack_start(*kreis1, Gtk::PACK_EXPAND_WIDGET, 0);
  m_box0->pack_start(*kreis2, Gtk::PACK_EXPAND_WIDGET, 0);
  m_box0->pack_start(*kreis3, Gtk::PACK_EXPAND_WIDGET, 0);
  m_box0->pack_start(*kreis4, Gtk::PACK_EXPAND_WIDGET, 0);
  m_box0->pack_start(*kreis5, Gtk::PACK_EXPAND_WIDGET, 0);

  window->add(*m_box0);
  window->show_all();

  Gtk::Main::run(*window);
  return 0;
}

A.3  Das Telespiel: Ping

#include <gtkmm/window.h>
#ifndef __MOVABLE_H

#define __MOVABLE_H ;

class Movable {
  int _xPos;
  int _yPos;
  int _xDir;
  int _yDir;

  int _width;
  int _height;

public:
  Movable();
  Movable(const int xPosVal,const int yPosVal);
  virtual ~Movable();

  void setXPos(const int val);
  void setYPos(const int val);
  void setXDir(const int val);
  void setYDir(const int val);
  void setWidth(const int val);
  void setHeight(const int val);

  int getXPos(){return _xPos;}
  int getYPos(){return _yPos;}
  int getXDir(){return _xDir;}
  int getYDir(){return _yDir;}
  int getWidth(){return _width;}
  int getHeight(){return _height;}

  bool touches(Movable &other);

  virtual void move(const int maxX,const int maxY);
  virtual void paint(Glib::RefPtr<Gdk::Window> window
                    ,Glib::RefPtr<Gdk::GC> gc_);

private:
  bool touchesHorizontal(Movable &other);
  bool touchesVertical(Movable &other);
};

#endif /* __MOVABLE_H */

#include "Movable.h"


Movable::Movable(){
  _xPos=0;
  _yPos=0;
  _xDir=1;
  _yDir=1;

  _width=10;
  _height=10;
}

Movable::Movable(const int xPosVal,const int yPosVal){
  _xPos=xPosVal;
  _yPos=yPosVal;
  _xDir=10;
  _yDir=10;

  _width=10;
  _height=10;
}

Movable::~Movable(){}

void Movable::setXPos(const int val){_xPos=val;}
void Movable::setYPos(const int val){_yPos=val;}
void Movable::setXDir(const int val){_xDir=val;}
void Movable::setYDir(const int val){_yDir=val;}
void Movable::setWidth(const int val){_width=val;}
void Movable::setHeight(const int val){_height=val;}

void Movable::move(const int maxX,const int maxY){ 
  _xPos = _xPos + _xDir;
  _yPos = _yPos + _yDir;
}

void Movable::paint
    (Glib::RefPtr<Gdk::Window> window,Glib::RefPtr<Gdk::GC> gc_){
}

bool Movable::touches(Movable &other){
    return (   touchesHorizontal(other) 
            && touchesVertical(other));
  }

bool Movable::touchesHorizontal(Movable &other){
    const int otherRight = other._xPos+other._width;
    const int thisRight  = _xPos+_width;

    return (_xPos<=other._xPos  && other._xPos<=thisRight)
        || (_xPos<=otherRight   && otherRight<=thisRight)
        || (_xPos>=other._xPos  && otherRight>=_xPos);

}

bool Movable::touchesVertical(Movable &other){
    const int otherUpper = other._yPos+other._height;
    const int thisUpper  = _yPos+_height;

    return   (_yPos<=other._yPos    && other._yPos<=thisUpper)
          || (_yPos<=otherUpper     && otherUpper<=thisUpper)
          || (_yPos>=other._yPos    && otherUpper>=thisUpper);
}

#include "Movable.h"

class Ball  : public Movable{
public:
  Ball();
  ~Ball();

  virtual void move(const int maxX,const int maxY);
  virtual void paint(Glib::RefPtr<Gdk::Window> window
                    ,Glib::RefPtr<Gdk::GC> gc_);
};

#include <gdkmm/window.h>
#include <gtkmm/window.h>
#include "Ball.h" 

Ball::Ball(){}
Ball::~Ball(){}

void Ball::move(const int maxX,const int maxY){
  Movable::move(maxX,maxY);

  if (getXPos()>=maxX+80) setXPos(30);     
  if (getXPos()<=-80) setXPos(maxX-40);

  if (getYPos()>=maxY-getHeight() || getYPos()<=0)
    setYDir(-getYDir());
}

void Ball::paint(Glib::RefPtr<Gdk::Window> window
                ,Glib::RefPtr<Gdk::GC> gc_){
  window->draw_arc(gc_, 1,getXPos(),getYPos()
                  ,getWidth(),getHeight(),0,360*64);
}

#include "Movable.h"

class Paddle  : public Movable{
public:
  Paddle(const int xPosVal,const int boardHeight);
  ~Paddle();

  virtual void move(const int maxX,const int maxY);
  virtual void paint(Glib::RefPtr<Gdk::Window> window
                    ,Glib::RefPtr<Gdk::GC> gc_);

  static const int yMoveVal =11;
};

#include <gdkmm/window.h>
#include <gtkmm/window.h>
#include "Paddle.h" 

Paddle::Paddle(const int xPosVal,const int boardHeight) 
  :Movable(xPosVal,boardHeight-50){
  setWidth(10);
  setHeight(50);
  setXDir(0);
  setYDir(0);
}

Paddle::~Paddle(){}

void Paddle::move(const int maxX,const int maxY)
{ Movable::move(maxX,maxY);
  if (getYPos()>=maxY-getHeight()) setYPos(maxY-getHeight());

  if (getYPos()<0) setYPos(0);
}

void Paddle::paint(Glib::RefPtr<Gdk::Window> window
                  ,Glib::RefPtr<Gdk::GC> gc_){
  window->draw_rectangle(gc_,1,getXPos()
                        ,getYPos(),getWidth(),getHeight());
}

#include <gtkmm/drawingarea.h>
#include <gdkmm/window.h>
#include <gtkmm/window.h>

class GameCanvas : public Gtk::DrawingArea{
public:
  GameCanvas();
  virtual ~GameCanvas();
  bool timer_callback();

  virtual void moveObjects(const int maxX,const int maxY);
  virtual void paintObjects(Glib::RefPtr<Gdk::Window> window
                           ,Glib::RefPtr<Gdk::GC> gc_);
  virtual void doChecks();


  //Overridden default signal handlers:
  virtual void on_realize();
  virtual bool on_expose_event(GdkEventExpose* event);

  Glib::RefPtr<Gdk::GC> gc_;
  Gdk::Color black_, white_;
};

#include <gtkmm/drawingarea.h>
#include <gdkmm/colormap.h>
#include <gdkmm/window.h>
#include <gtkmm/window.h>

#include "GameCanvas.h"


GameCanvas::GameCanvas(){
  Glib::RefPtr<Gdk::Colormap> colormap = get_default_colormap();
  black_ = Gdk::Color("black");
  white_ = Gdk::Color("white");
  
  colormap->alloc_color(black_);
  colormap->alloc_color(white_);
  set_size_request(400, 200);

  Glib::signal_timeout()
   .connect(SigC::slot(*this,&GameCanvas::timer_callback), 3);

  add_events(Gdk::EXPOSURE_MASK);
}

GameCanvas::~GameCanvas(){}

void GameCanvas::on_realize(){
  // We need to call the base on_realize()
  Gtk::DrawingArea::on_realize();

  // Now we can allocate any additional resources we need
  Glib::RefPtr<Gdk::Window> window = get_window();
  gc_ = Gdk::GC::create(window);
  window->set_background(black_);
}

bool GameCanvas::on_expose_event(GdkEventExpose*){
  // we need a ref to the gdkmm window
  Glib::RefPtr<Gdk::Window> window = get_window();

  window->clear();

  gc_->set_foreground(white_);

  paintObjects(window,gc_);
  return true;
}

bool GameCanvas::timer_callback(){
  int winx, winy, winw, winh, wind;
  Glib::RefPtr<Gdk::Window> window = get_window();
  window->get_geometry(winx, winy, winw, winh, wind);

  moveObjects(winw,winh);
  doChecks();

  queue_draw();

  // never disconnect timer handler
  return 1;
}

void GameCanvas::moveObjects(const int maxX,const int maxY){}

void GameCanvas::paintObjects(Glib::RefPtr<Gdk::Window> window
                             ,Glib::RefPtr<Gdk::GC> gc_){}

void GameCanvas::doChecks(){}

#include <gtkmm/drawingarea.h>
#include <gdkmm/colormap.h>
#include <gdkmm/window.h>
#include <gtkmm/box.h>
#include <gtkmm/main.h>
#include <iostream>
#include "Ball.h"
#include "Paddle.h"
#include "GameCanvas.h"

using namespace std;

class Ping : public GameCanvas{
public:
  Ping();
  ~Ping();
  bool timer_callback();

  int pointsLeftPlayer;
  int pointsRightPlayer;
  bool newBall;

  Ball ball;
  Paddle leftPaddel;
  Paddle rightPaddel;

  virtual void moveObjects(const int maxX,const int maxY);
  virtual void paintObjects(Glib::RefPtr<Gdk::Window> window
                           ,Glib::RefPtr<Gdk::GC> gc_);

  virtual void doChecks();

  virtual bool on_key_press_event(GdkEventKey* event);
  virtual bool on_key_release_event(GdkEventKey* event);
};

Ping::Ping():GameCanvas(),leftPaddel(10,200),rightPaddel(380,200){
  set_flags(Gtk::CAN_FOCUS);
  pointsLeftPlayer = 0;
  pointsRightPlayer = 0;
}


Ping::~Ping(){}

void Ping::paintObjects(Glib::RefPtr<Gdk::Window> window
                       ,Glib::RefPtr<Gdk::GC> gc_){
  ball.paint(window,gc_);
  leftPaddel.paint(window,gc_);
  rightPaddel.paint(window,gc_);
}

void Ping::moveObjects(const int maxX,const int maxY){ 
  this->ball.move(maxX,maxY);
  this->leftPaddel.move(maxX,maxY); 
  this->rightPaddel.move(maxX,maxY); 
}

void Ping::doChecks(){
  if (ball.touches(leftPaddel) || ball.touches(rightPaddel))
    ball.setXDir(-ball.getXDir()); 

  if (ball.getXPos()<0&& newBall){ 
    pointsRightPlayer++;newBall=false;
  }else if (ball.getXPos()>400&&newBall){
    pointsLeftPlayer++;newBall=false;
  }else if (!newBall && ball.getXPos()>40 
                     && ball.getXPos()<80) {
    newBall=true;
  }
}

bool Ping::on_key_press_event(GdkEventKey* event){
  if(event->keyval == 'l')
    rightPaddel.setYDir(- Paddle::yMoveVal);
  else if(event->keyval == 'a')
    leftPaddel.setYDir(- Paddle::yMoveVal);
}
 
bool Ping::on_key_release_event(GdkEventKey* event){
  if(event->keyval == 'l')
    rightPaddel.setYDir(Paddle::yMoveVal);
  else if(event->keyval == 'a')
    leftPaddel.setYDir(Paddle::yMoveVal);
  else cout << event->keyval << endl;
}

int main(int argc, char** argv){
  Gtk::Main main_instance (argc, argv);
  Gtk::Window* window = new Gtk::Window();
  Gtk::HBox m_box0(false,0);

  Ping* p = new Ping();
  m_box0.pack_start(*p, Gtk::PACK_EXPAND_WIDGET, 0);
  window->add(m_box0);
  window->show_all();

  Gtk::Main::run(*window);
  delete p;
  delete window;
  return 0;
}

Appendix B
Gesammelte Aufgaben

void fak(int x,int* result);

float nullstelle(float (*f) (float),float mi,float ma);

#include "Nullstellen.h"
#include <iostream>

float f1(float x){return 2*x*x*x+5;}
float f2(float x){return 2*x +1 + x*x*x/4 ;}
float f3(float x){return 10*x+5;}
float f4(float x){return 0;}
float f5(float x){return x*x;}

void teste(float (*f)(float)){
  const float fn = nullstelle(f,-10,11);
  std::cout << "n = "<<fn<< ", f(n) = " << f(fn) << std::endl;
}

int main(){
  teste(f1);
  teste(f2);
  teste(f3);
  teste(f4);
  teste(f5);
}

typedef int (* intfunction)(int);

int compose(intfunction fs [],int length,int x);

compose({f₁,... f_n},n,x) = f_n(f_n-1(...(f₁(x))...))

#include <iostream>
#include "Compose.h"

int f1(int x){return x*x;}
int f2(int x){return x;}
int f3(int x){return x+2;}
int f4(int x){return x*4;}
int f5(int x){return -x*x*x;}

int main(){
    intfunction fs [] = {f1,f2,f3,f4,f5};
    std::cout << compose(fs,5,2)<<std::endl;
}

{\bf \alph{unteraufgabe})} Implementieren Sie eine Funktion
void bubbleSort(int xs [],int length ),
die Elemente mit dem Bubblesort-Algorithmus der Größe nach sortiert. Schreiben Sie ein paar Tests für Ihre Funktion.
{\bf \alph{unteraufgabe})} Schreiben Sie jetzt eine verallgemeinerte Sortierfunktion, in der die Sortierrelation als Parameter mitgegeben wird. Die Sortierfunktion soll also eine Funktion höherer Ordnung mit folgender Signatur sein:
void bubbleSortBy(int xs [],int length, bool (*smaller) (int,int) )

fold(xs,l,op,st) = op(... op(op(op(st,xs[0]),xs[1]),xs[2])...,xs[l-1])

fold({x₀,x₁,,...,x_l-1},l,op,st) = st op x₀ op x₁ op x₂ op ... op x_l-1

#include <iostream>

int add(int x,int y){return x+y;}
int mult(int x,int y){return x*y;}

int fold(int xs [],int length,int (*foldOp)(int,int),int startV);

int main(){
  int xs [] = {1,2,3,4,5};
  std::cout << fold(xs,5,add,0)<< std::endl;
  std::cout << fold(xs,5,mult,1)<< std::endl;
}

{\bf \alph{unteraufgabe})} int last(struct IntList * dieses)
{\bf \alph{unteraufgabe})} struct IntList * concat(struct IntList * xs,struct IntList * ys)
{\bf \alph{unteraufgabe})} int elementAt(struct IntList * dieses,int i)
{\bf \alph{unteraufgabe})} int fold(struct IntList * dieses,int start,int(*foldOp)(int,int))

template <typename a, typename b, typename c>
c composition(c (* f2)(b),b (* f1)(a),a x);

• const std::string operator[](const int i) const; soll das i-te Element zurückgeben.
• const StringLi* operator-(const int i) const; soll eine neue Liste erzeugen, indem von der Liste die ersten i Elemente weggelassen werden.
• const bool operator<(const StringLi* other) const; soll die beiden Listen bezüglich ihrer Länge vergleichen.
• const bool operator==(const StringLi* other) const; soll die Gleichheit auf Listen implementieren.

{\bf \alph{unteraufgabe})}
Schreiben Sie eine Klasse, die eine Hashmenge realisiert. Ihre Klasse soll der folgenden Kopfdatei entsprechend Funktionalität bereitstellen
HashSet
#include "Li.h"

template <class elementType>
class HashSet {
  protected:
    int capacity;
    int (*hashFunction)(elementType);
    Li<elementType>* hashArray [];
  
  public:
    HashSet(int c, int (*hashF)(elementType));
    virtual ~HashSet();
    void add(elementType el);

    bool contains(elementType el);    
    std::string toString();
};

{\bf \alph{unteraufgabe})} Schreiben Sie Testfälle und betrachten Sie, wie gut in diesen Tests die Elemente gestreut liegen.

{\bf \alph{unteraufgabe})} Schreiben Sie eine generische Funktion:

template <typename A>
LazyList<A>* repeat(A x)

die eine Liste erzeugt, in der unendlich oft Wert x wiederholt wird.
{\bf \alph{unteraufgabe})} Schreiben Sie eine Funktion, die eine unendliche Liste von Pseudozufallszahlen erzeugt. Benutzen sie hierzu folgende Formel:
z_n+1 = (91 * z_n + 1) mod 347

{\bf \alph{unteraufgabe})} Implementieren Sie jetzt die Funktion fold zur Benutzung für allgemeine Behälterklassen im STL Stil entsprechend der Signatur:
STLFold
template <typename Iterator,typename BinFun,typename EType>
EType fold(Iterator begin,Iterator end,BinFun f,EType start);

{\bf \alph{unteraufgabe})} Testen Sie Ihre Implementierung mit folgendem Programm:
STLFoldTest
#include <vector>
#include <string>
#include <functional>
#include <iostream>
#include "STLFold.h"

int addLength(int x,std::string s){return x+s.length();}

std::string addWithSpace(std::string x,std::string y){
    return x+" "+y;
}

int main(){
  int xs []={1,2,3,4,5};
  int result;
  result = fold(xs,xs+5,std::plus<int>(),0);
  std::cout << result << std::endl;
  result = fold(xs,xs+5,std::multiplies<int>(),1);
  std::cout << result << std::endl;

  std::vector<std::string> ys;
  ys.insert(ys.end(),std::string("friends"));
  ys.insert(ys.end(),std::string("romans"));
  ys.insert(ys.end(),"contrymen");
  result = fold(ys.begin(),ys.end(),addLength,0);
  std::cout << result << std::endl;

  std::string erg
    = fold(ys.begin(),ys.end()
          ,std::plus<std::string>(),std::string(""));
  std::cout << erg << std::endl;

  erg=fold(ys.begin(),ys.end(),addWithSpace,std::string(""));
  std::cout << erg << std::endl;
}

{\bf \alph{unteraufgabe})} Schreiben Sie weitere eigene Tests.

Index

List of Figures

Bibliography

[BCK⁺01]

G. Bracha, N. Cohen, Chr. Kemper, St. Marx, S. E. Panitz, D. Stoutamire, K. Thorup, and Ph. Wadler. Adding generics to the java programming language: Participant draft specification. Java Community Process 14, 4 2001.

[CFH⁺98]

Norman Chin, Chris Frazier, Paul Ho, Zicheng Lui, and Kevin P. Smith. The OpenGL Graphics System Utility Library.
ftp://ftp.sgi.com/opengl/doc/opengl1.2/glu1.3.ps, 1998.

[Gru01]

Ulrich Grude. C++ für Java-Programmierer.
www.tfh-berlin.de/~grude/SkriptCPPSS01.pdf, 2001. Skript, TFH Berlin.

[Ing78]

Daniel H. H. Ingalls. Smalltalk-76 programming system. In Proc. 5th Annual ACM Symposium on Principles of Programming Languages, 1978.

[Kil96]

Mark J. Kilgard. The OpenGL Utility Toolkit (GLUT).
http://www.opengl.org/developers/documentation/glut/glut-3.spec.ps, 1996.

[NH02]

Alexander Niemann and Stefan Heitsiek. Das Einsteigerseminar: C++ Objektorientierte Programmierung. verlag moderne industrie Buch AG & Co KG, Bonn, 2002.

[Pan02]

Sven Eric Panitz. Programmieren I.
www.panitz.name/prog1/index.html, 2002. Skript zur Vorlesung, TFH Berlin.

[Pan03a]

Sven Eric Panitz. HOpenGL - 3D Graphics with Haskell, A small Tutorial.
www.panitz.name/hopengl/index.html, 2003. Online Script, TFH Berlin.

[Pan03b]

Sven Eric Panitz. Programmieren II.
www.panitz.name/prog2/index.html, 2003. Skript zur Vorlesung, TFH Berlin.

[RL03]

Heike Ripphausen-Lipa. Programmieren II (TI).
www.tfh-berlin.de/~ripphaus/Prg2/Prg2.htm, 2003. Skript, TFH Berlin.

[Tur85]

D. A. Turner. Miranda: A non-strict functional language with polymorphic types. In Functional Programming Languages and Computer Architecture, number 201 in Lecture Notes in Computer Science, pages 1-16. Springer, 1985.

[WBN⁺97]

Mason Woo, OpenGL Architecture Review Board, Jackie Neider, Tom Davis, and Dave Shreiner. OpenGL Programming Guide 3rd Edition. Addison-Wesley, Reading, MA, 1997.

[Wie99]

Greg Wiegand. Teach Yourself C++ in 21 Days. www.mcp.com/sams, 1999.