/*

IO mit printf/scanf

Funktionen und Vorwärtsreferenzen

 */


#include <stdio.h>

void testPrintf() {
  int i = 5;
  float f = 3.2;
  char c = 'a';

  /*
   Beobachtung:
     Benoetigen Konvertierungsfunktionen
        int -> string
        float -> string
        char -> string

   Impliziert
    printInt welche ein int als Argument nimmt
    printFloat welche ein float als Argument nimmt
    ...

   Fuer den User, brauchen was "komfortableres".

   */

  printf("\n i = %d", i);
  printf("\n f = %f", f);
  printf("\n c = %c", c);

  printf("\n i = %d, f = %f, c = %c", i, f, c);


 // Typinformation kodiert im Formatstring
 // Z.B. Platzhalter %f steht fuer eine float Zahl.
 // printf ist eine "variadic" function, nimmt einen Variable Anzahl von Argumenten.

 // Beachte:
 // Typen der Argumente muessen mit Platzhaltern kompatibel sein.


 // Hier sollte anstatt %f entweder %c oder %d stehen.
 // printf ("Characters: %c %f \n", 'a', 65);

 // Zuviele Argumente.
 // printf ("Characters: %c %c \n", 'a', 65, 444);

 // Beachte. Undefiniertes Verhalten.
 // Werden Default Werte verwendet?

 // printf ("Characters: %c %c %d %f %s \n", 'a');

 // printf ("float: %c %c \n", 3.1416, 2.5);
}

// Funktionsdeklaration.
// Teile dem Compiler mit, es gibt eine Funktion von diesem Namen.
// Deren Funktionsdefinition findet sich unten.
// Bekannt als "forward declaration".
// Notwendig im Fall von sich gegenseitig aufrufenden Funktionen.

void testScanf();

int main() {
  // testPrintf();
    testScanf();
}


void testScanf () {
  int i;

  /*

    Bemerkung:
          Endezeichen ist "return".

   Betrachte Eingabe.
   Benoetigen das aequivalent zu printInt, ...
    scanInt    : string -> int
    scanFloat  : string -> float
    scanChar   : string -> char

    Ausgabe:

          printf("\n i = %d", i);

    Eingabe:

          scanf("\n i = %d", i);


         Woher weiss, scanf wo "i" im Speicher liegt.
         Beachte, Variable i wird hier als Wert uebertragen.

         D.h. wir benoetigen

         i = scanfInt("\n i = %d");


         ??? Keine praktikable Loesung, viel zu umstaendlich.

       Idee:
         Was ist falls wir die Referenz auf i an scanf uebergeben koennen?
   */


  printf ("\n Eingabe Dezimalzahl: ");
  scanf ("%d",&i);

  printf("\n i = %d", i);


  // Was bedeutet &i?

  // "&" ist der Adressoperator.
  // 1. Liefert die (Speicher)adresse der Variablen i.
  // 2. "scanf" wandelt den Eingabestring in einen Dezimalwert um.
  // 3. Dieser Dezimalwert wird an der Speicheradresse, an der
  //    Variable i sich befindet abgelegt.

  // Beobachtungen.

  // Mittels "&" kann man also call-by-reference darstellen.

  // Wieso wird der Dezimalwert nicht per Rueckgabe geliefert?
  // Z.B.
  // i = scanf("%d");
  //
  // Dann waere scanf einen Funktion mit Argument string und Rueckgabe int.
  //
  // Was ist mit der Eingabe von Zeichen?
  // char c;
  // c = scanf("%c");
  //
  // In diesem Fall waere scanf eine Funktion mit Argument string und Rueckgabe char.
  //
  // Solche eine Form von "overloading" ist nicht erlaubt!


}

/*

Strukturen

Zeiger

Call-by-value versus call-by-reference

 */


#include <stdio.h>


// C hat Strukturen.

// structs in C = classes in Java aber:
//  - keine Methodendeklarationen
//  - alle Feldelemente sind oeffentlich
//  - keine Konstruktoren (und keine Vererbung)

struct Punkt {
  int x;
  int y;
}; // Beachte ";", in Java nicht notwendig

// Sprachgebrauch.
// x ist eine Instanzvariable,
// im C Kontext wird x auch eine Feldvariable genannt.
// Im Englischen "member" ...


void printPunkt(struct Punkt p) {
  printf("\n Punkt = (%d,%d)", p.x, p.y);
}


// User liefert Werte (als Strings eingegeben auf der Konsole)
struct Punkt scanPunkt() {
  struct Punkt p;

  printf("\n Eingabe x:");
  scanf("%d", &p.x);         // Frage: Ist die Interpretation
                             // (a) (&p).x   oder
                             // (b) &(p.x)

  printf("\n Eingabe y:");
  scanf("%d", &p.y);

  return p;
}

// Beachte.

// Elementweise Eingabe.
// Uebergebe an scanf die Referenz auf p.x, "scanf("%d", &p.x);"
//
// Notation:
// p.x Zugriff auf Feldelement x in der Struktur p
// Unaerer Operator &, liefert Referenz.
//
//    &p.x
//
// Wie ist die Interpretation?
//
// (1)  &(p.x)   bedeutet, baue Referenz auf Feldelement x in p
//
// oder
//
// (2)  (&p).x   bedeutet, baue Referenz auf p und wir
//               interpretieren die Referenz als Struktur und
//               greifen wir auf das Feldelement x zu.
//
//  Der Compiler waehlt die Interpretation (1).
// In C gilt, dass "." bindet staerker als "&".


// In C gilt call-by value.
// Deshalb ist die Eingabe nicht von aussen sichtbar.
void scanPunkt2(struct Punkt p) {
  struct Punkt r;
  r = scanPunkt();
  p = r; // Bedeutet, p.x = r.x; p.y = r.y;
}

// Call-by-reference via Zeiger ("pointer").
void scanPunktRef(struct Punkt* p) {
  struct Punkt r;

  r = scanPunkt();

  (*p).x = r.x;  // Beachte: *p.x bedeutet Zugriff auf x und danach Dereferenzierung.
  (*p).y = r.y;
}

// p ist eine Zeigervariable, siehe obige Typdeklaration "struct Punkt* p".

// Betrachte
// (*p).x
//  (1) Via (*p) greifen wir auf die Struktur
//  (2) Via .x greifen wir auf das Element mit dem Namen x zu.
//
//  Was bedeutet dann "*p.x"?
// "." bindet am staerksten, deshalb wird "*p.x" interpretiert als "*(p.x)".
// In unserem Fall liefert
// "*(p.x)" einen Fehler (weil p ist die Referenz und keine Struktur).


void testPunkt() {
  struct Punkt p = {1,2};
  struct Punkt q,r;

  printPunkt(p);

  q = scanPunkt();
  printPunkt(q);
}

// Liefert nicht die erwartete Ausgabe
void testPunkt2() {
  struct Punkt t;
  t.x = 3;
  t.y = 4;

  scanPunkt2(t);
  // An der Stelle kopieren wir
  // 3 nach p.x
  // 4 nach p.y
  // Annahme, p ist der Parameter
  // von scanPunkt2.
  printPunkt(t);
}

void testPunktRef() {
  struct Punkt p;

  scanPunktRef(&p);
  printPunkt(p);
}


int main() {
  // testPunkt();
  // testPunkt2();
  testPunktRef();
}


// Folgende Varianten sind aequivalent zu scanPunktRef

void scanPunktRef2(struct Punkt* p) {
  struct Punkt r;

  r = scanPunkt();

  p->x = r.x;
  p->y = r.y;
}


void scanPunktRef3(struct Punkt* p) {
  struct Punkt r;

  r = scanPunkt();

  *p = r;
}

void scanPunktRef4(struct Punkt* p) {

  *p = scanPunkt();
}


// Diese Variante funktioniert NICHT.
// Variable r ist allokiert auf dem Stack.
// Deren Speicherbereich wird nach Ruecksprung geloescht.
void scanPunktRef5(struct Punkt* p) {
  struct Punkt r;

  r = scanPunkt();

  p = &r;
}

#include <stdio.h>

  // Arrays in C.
  // Alle Elemente sind vom gleichen Typ.
  // In unserem Fall. Ein Array von chars.

  // Ein C string ist dargestellt als ein Array von chars.
  // Beachte. In Java gibt es einen string Datentyp welcher auch die
  // Laenge des Arrays verwaltet.
  // In C wird folgender Trick angewandt um die Laenge des strings zu verwalten.
  // Das Ende eines strings in C wird mit einem speziellen ASCII Code gekennzeichnet.
  // Der ASCII Code 0 ("Null") wird verwendet, um das Ende des strings zu markieren.
  // Dies wird auch als "Null Terminierung" bezeichnet und diesen
  // speziellen ASCII Code nennen wir auch Null Terminator.


/* Berechne die Laenge eines strings.
   strings sind Arrays von chars.

    "" hat die Laenge Null.
    "a" hat die Laenge eins.

*/

int len(char s[]) {
  int i = 0;

  // Teste die einzelnen Zeichen, bis wir auf die Null Terminierung treffen.
  while(s[i] != '\0') {
    i++;
  }
  return i;
}


// Es gibt keine Arrays in C.
// Arrays in C werden durch Zeiger emuliert.
// Ein Array ist dargestellt als Zeiger auf das erste Element.

// Variable p ist eine Referenz (aka Zeiger, "pointer") auf ein Zeichen (char).
// In C, ist der Name des Arrays immer die Referenz auf das erste Element in dem Array.
int len2(char* p) {
  int i = 0;

  // Beachte. Dereferenzierung, via "*p" greifen wir auf das Zeichen zu auf welches
  // der Zeiger p referenziert.
  while(*p != '\0') {
    p++;
    // Kurzform fuer
    // p = p + 1;
    // Der Zeiger p verweist auf das naechste Element im Speicher.
    // Beachte. Alle Elemente sind vom gleichen Typ.
    // "+1" bedeutet, der Compiler kennt die Groesse (in Bytes) eines Elements und
    // kann damit die absoluten Speicheradressen berechnen.

    i++;
  }
  return i;
}


void testStrings() {

  char str[10] = "Hello";

  // Die Groesse des Arrays ist hier implizit.
  // Frage: Wieviele Zeichen sind in dem Array str?
  // Die logische Antwort ist 5, aber diese ist falsch!!!!
  // Es sind 5+1 = 6 Zeichen.
  // "+1" wegen dem Null Terminator.

  char str2[] = "123456"; // 6 + 1 Zeichen werden allokiert.
  // Beachte. Der Compiler berechnet automatisch die Groesse des Arrays.
  // Im Fall von strings wird immer "eins dazugerechnet", wegen dem Null Terminator.
  int i;

  char str3[] = { '1', '2' }; // 1. Der Compiler allokiert nur 2 Zeichen.
                              // 2. Die Null Terminierung fehlt.
  char str4[] = { '1', '2', '\0' };
  // Beachte:
  // Im Fall wir initialisieren ein Array von chars Elementweise,
  // wird NICHT automatisch der Null Terminator hinzugefuegt.


  printf("\n");

  for(i = 0; i < 5; i++) {
    printf("%c",str[i]);
    // Zugriff auf ein Array wie in Java.
  }

  printf("\n len(str) = %d", len2(str));

  printf("\n len(str2) = %d", len(str2));

  printf("\n len(str3) = %d", len(str3));

  printf("\n len(str4) = %d", len2(str4));

}

/*

Beispiel Ausgabe (auf meinem mac)

Hello
 len(str) = 5
 len(str2) = 6
 len(str3) = 3     *******
 len(str4) = 2%

D.h.

 str3 angelegt als char Array der Groesse, bestehend aus '1' und '2',
 dies sind die Positionen str3[0] und str3[1].

 Wie's scheint liegt an Position str3[2] irgendein Zeichen
 und an Position str3[3] liegt der Null Terminator.

 => Es gibt keinen Array-out-bounds Check in C !!!!!!!!!!!!!


 */


void testArrayVsPointer() {
  int x[5] = {1,2,3,4,5};
  int i;
  int* p;

  printf("\n");
  for(i=0; i < 4; i++) {
    printf("%d ",x[i]);   // x[i]  Zugriff auf Element in x an der Position i
  }


  printf("\n");
  for(i=0; i < 4; i++) {
    printf("%d ",*(x+i)); // *(x+i)  von x ausgehend, gehe i Element im Speicher nach oben
  }

  printf("\n");
  p = x;
  // p = &x[0];
  for(i=0; i < 4; i++, p++) {
    printf("%d ",*p);
  }

}



int main() {
  printf("\n");

  testArrayVsPointer();
  testStrings();

}

#include <stdio.h>

int len(char s[]) {
  int i = 0;

  // Teste die einzelnen Zeichen, bis wir auf die Null Terminierung treffen.
  while(s[i] != '\0') {
    i++;
  }
  return i;
}

void test2() {

  char s2[6] = {'H','a', 'l', 'l', 'o'};     // WARNUNG. '\0' fehlt!
  char s[6] = {'H','a', (char)(32), 'l', 'o', '\0'};

  char s3[] = "Hallo";
  // Groesse des Arrays wird automatisch berechnet. Hier 6 Elemente.
  // Compiler fuegt automatisch die '\0' ein.

  int i;
  char* p = &s3[0] ; // Referenz auf das erste Zeichen im Array s3

  for(i=0; i < len(s3); /*i++, p++ */) {
    printf("%c", *p);
    i = i + 1;
    p = p + 1; // Nachfolger von p !!
    //p = p + 2; // Nachfolger vom Nachfolger von p !!
  }

  printf("\n");
  p = &s3[0]; // Referenz auf das erste Zeichen in s3.
  for(i=0; i < len(s3); i++) {
    printf("%c", *(p + i)); // p + i  verweist auf den iten Nachfolger
                            // *(p + i) liest den entsprechenden Wert
  }

  // In C ist der Name des Arrays die Referenz auf das erste Zeichen!
  printf("\n");
  for(i=0; i < len(s3); i++) {
    printf("%c", *(s3 + i)); // s3[i] ist syntaktischer Zucker fuer *(s3 + i)
  }

  /*

  for(i=0; i < len(s3) + 50; i++) {
    printf("%c", s3[i]);
    // Kein "array out of bounds check" in C!
  }
  */

  printf("\n %d", len(s));
  printf("\n %d", len(s2));
  printf("\n %d", len(s3));

}


int main() {

  test2();

}

// Funktionszeiger.

#include <stdio.h>

// Parameter f ist ein Zeiger (Referenz) auf eine Funktion.
// Diese Funktion erwartet einen int Wert und liefert einen int Wert zurueck.
void mapInt(int* p, int len, int (*f)(int)) {
 int i;
 for(i=0; i<len; i++)
   p[i] = (*f)(p[i]);
}


int inc(int x) { return x+1; }
int square(int x) { return x*x; }


int main() {
   int x[5] = { 1,2,3,4,5 };
   mapInt(x,5,&inc);
   mapInt(x,5,&square);

   printf("%d", x[1]);

   return 0;
}


// Beachte.
// Oft werden "shorthands" via typedef verwendet.

typedef int (*intFunc)(int);

void mapInt2(int* p, int len, intFunc f) {
 int i;
 for(i=0; i<len; i++)
   p[i] = (*f)(p[i]);
}

// Komplexe Datentypen (Strukturen)
// zur Beschreibung von Arrays mit Laengeangabe.

// Manuelle Speicherverwaltung.

#include <stdio.h>
// printf, ...
#include <stdlib.h>
// malloc, ...

// Integer array.
// Zeiger start verweist auf erstes Element.
// len beschreibt die Laenge.
struct IntArray {
  int* start;
  int len;
};

void print_IntArray(struct IntArray x) {
  int i=0;
  int* p = x.start;

  for(i=0; i<x.len; i++, p++) {
    printf("%d", *p);
  }


  /*
  // oder via array Zugriff
  for(i=0; i<x.len; i++) {
    printf("%d", x.start[i]);
  }
  */

}

// Wir wollen auf dem heap ein integer Array
// der Groesse n mit den Intialwerten intial anlegen.
struct IntArray new_IntArray(int n, int initial) {
  int* p = malloc(n * sizeof(int)); // Allokiert Bytes im Speicher
                                    // Speicher fuer n Integer Werte
  // alloc ist eine Art von "new", man muss aber den Speicher in Bytes allokieren.
  struct IntArray x = {p, n};
  int i = 0;

  for(i=0; i<n; i++, p++) {
    *p = initial;
    // Beachte.
    // Typinformation, hier int*, ist wichtig,
    // um die Dereferenzierung auszufuehren.
  }

  return x;
}

// In C, manuelle Speicherkontrolle.
// Deshalb muss der via malloc allokierte Speicher, explizit freigegeben werden.
void delete_IntArray(struct IntArray x) {
  free(x.start);
}

int len_IntArray(struct IntArray x) {
  return x.len;
}

void testIntArray() {
  struct IntArray x = new_IntArray(8,14);
  struct IntArray y = new_IntArray(4,3);

  print_IntArray(x);
  print_IntArray(y);


  delete_IntArray(x);
  delete_IntArray(y);


  print_IntArray(y);

  // Beachte. Potentielle Speicherverletzung.
  // Speicher als "free" deklariert. Aber wir greifen auf "x" zu.
  // Keine Garantie
  //  (a) welche Werte sich in dem IntArray befinden,
  //  (b) ob Zugriff moeglich.

}

void testIntArray2() {
  struct IntArray x = new_IntArray(8,14);
  struct IntArray y = new_IntArray(4,0);

  print_IntArray(x);
  print_IntArray(y);

  delete_IntArray(x);

  // Speicherleck.
  // Es fehlt
  // delete_IntArray(y);

}


void testIntArray2b() {
  struct IntArray x = new_IntArray(8,14);
  struct IntArray y = new_IntArray(4,0);

  print_IntArray(x);
  print_IntArray(y);

  delete_IntArray(x);

  delete_IntArray(y);
  delete_IntArray(y); // doppeltes delete!

}

void testIntArray3() {
  struct IntArray x = new_IntArray(8,14);
  struct IntArray y;

  y = x;
  // Elementweises kopieren:
  // x.start = y.start;
  // x.len = y.len;
  // Die "start" Zeiger in x und y
  // verweisen auf den gleichen Speicherbereich.


  print_IntArray(x);
  print_IntArray(y);

  delete_IntArray(x);
  // impliziert den Aufruf free(x.start)

  delete_IntArray(y);
  // impliziert den Aufruf free(y.start)

  // Es gilt.
  // Speicher kann nur einmal freigegeben werden!
  // Zweifacher "free" Aufruf mit gleichem Zeiger
  // fuehrt zum Absturz.

  // Problemstellung hier: Pointer aliasing
  // Wie koennen wir herausfinden welcher Speicher
  // wurde schon freigeben?
  //
  // In C gibt es wenig "Komfort",
  // es wird viel, viel besser in C++ (oder wir verwenden eine Sprache mit automatischer Speicherverwaltung).
}

void testIntArray4() {
  struct IntArray x = new_IntArray(8,14);
  struct IntArray y;

  x = y;

  print_IntArray(x);
  print_IntArray(y);

  delete_IntArray(y);

  // y nicht initialisiert, ueberschreibt x!
  // Probleme sind:
  // 1. Speicherleck, da delete_IntArray(x) fehlt
  // 2. Zugriff auf x und y (da ueberschrieben und nicht initialisiert).
  // 3. Willkuehrliche Freigabe von Speicher in delete_IntArray(y), da nicht initialisiert.

}


int main() {
  printf("\n");


  // testIntArray();

  // testIntArray2();

  // testIntArray2b();

  // testIntArray3();
  // Absturz wegen zweifachem "free" des gleichen allokierten Speichers.

  testIntArray4();
}

#include <stdio.h>
#include <stdlib.h>


// Punkt im 2-dimensionalen Koordinatensystem
typedef struct { int x; int y; } point;



// Gleichheit zwischen Punkten
int eqPoint(point p, point q) {
  return (p.x == q.x) && (p.y == q.y);
}

// Ausgabe eines Punktes
void printPoint(point p) {
  printf("\n (x = %d, y = %d)", p.x, p.y);
}

// Koordinaten vertauschen
// Buggy !!!!!!!!!!!!
point switchPoint(point p) {
  p.x = p.y;
  p.y = p.x;

  return p;
}

//////////////////////
// Tests

// User Tests

void testUser() {
  point p = {2,2};

  printPoint(p);
  printPoint(switchPoint(p));
}

// Unit Tests

typedef struct { point input; point expected; } TestCase;

void testUnit() {
  int i;

  TestCase tests[] = {
    {{1,1}, {1,1}},
    {{2,2}, {2,2}}
  };


  for(i=0; i<2; i++) {
    if(eqPoint(switchPoint(tests[i].input),
           tests[i].expected)) {
      printf("\nOK");
    } else {
      printf("\nFAIL");
    }
  }
}

// Invarianten = Properties = Eigenschaften


int property1(point p) {
  return eqPoint(switchPoint(switchPoint(p)),
         p);
}

void testInvariante() {
  int i;
  point ps[10];

  // Generiere 10 Punkte zufaellig.
  for(i=0; i<10; i++) {
    ps[i].x = rand();
    ps[i].y = rand();
  }

  for(i=0; i<10; i++) {
    if(property1(ps[i])) {
      printf("\nOK");
    } else {
      printf("\nFAIL");
    }
  }

}

int main() {
  testUser();
  testUnit();
  testInvariante();
}

// Generische Datentypen und Funktionen in C.

#include <stdio.h>
#include <stdlib.h>

enum Type {
  INT = 0,
  FLOAT = 1
};

// Generische Variante
// void* ist der generischer Zeiger in C.
// Siehe "Object" in Java.
// void* ist wie ein Zeiger ohne Typinformation.
struct GenArray {
  enum Type type;
  void* start;
  int len;
};

int sizeOf(enum Type type) {
  switch(type) {
  case INT: return sizeof(int);
  case FLOAT: return sizeof(float);
  }
}

struct GenArray new_GenArray(int n, enum Type type) {
  void* q = malloc(n * sizeOf(type));

  struct GenArray x = {type, q, n};

  return x;
}


// Dereferenzierung von void* nicht moeglich.
// Wir verwenden die in dem enum kodierte Typinformation,
// um auf int*, float*, etc. zu casten.
void print_Type(void* elem, enum Type type) {
  int* i;
  float* f;

  switch(type) {
  case INT:
    i = (int*)(elem);
    printf("%d", *i);
    break;
  case FLOAT:
    f = (float*)(elem);
    printf("%f", *f);
    break;
  }
}

// Pointer Arithmetik fuer generischen Zeiger.
// Die in dem enum kodierte Typinformation ist wiederum wichtig.
void* inc_pointer_Type(void* p, enum Type type) {
  int* i;
  float* f;

  switch(type) {
  case INT:
    i = (int*)(p);
    i++;
    p = i;
    break;
  case FLOAT:
    f = (float*)(p);
    f++;
    p = f;
    break;
  }
  return p;
}

void print_GenArray(struct GenArray x) {
  int i=0;
  void* p = x.start;

  for(i=0; i<x.len; i++) {
    print_Type(p, x.type);
    p = inc_pointer_Type(p, x.type);
  }
}

void update_GenArray(struct GenArray x, int pos, void* new_Val) {
  int* i; int* i_Val;
  float* f; float* f_Val;

  // "array" out-of-bounds check
  if(pos >=0 && pos < x.len) {
    switch(x.type) {
    case INT:
      i = (int*)(x.start);
      i_Val = (int*)(new_Val);
      i[pos] = *i_Val;
      break;
    case FLOAT:
      f = (float*)(x.start);
      f_Val = (float*)(new_Val);
      f[pos] = *f_Val;
      break;
    }
  }

}

void test_GenArray() {
  struct GenArray x = new_GenArray(2, INT);
  struct GenArray y = new_GenArray(3, FLOAT);
  int i = 5;
  float f = 1.0;

  update_GenArray(x,0,&i);
  update_GenArray(x,1,&i);

  update_GenArray(y,0,&f);
  update_GenArray(y,1,&f);
  update_GenArray(y,2,&f);

  print_GenArray(x);

  print_GenArray(y);
}

int main() {
  printf("\n");
  test_GenArray();
}

#include <stdio.h>
#include <stdlib.h>

/*

Geometric objects.

Java pseudo-code.

class Shape {
 int area();
}

class Rectangle extends Shape {
  int length;
  int width;
  int area() { return length * width; }
}

class Square extends Shape {
  int length;
  int area() { return length * length; }
}

// Annahme, frei-stehende Funktionen in Java moeglich.
int sumArea (Shape s1, Shape s2) {
  return s1.area() + s2.area();
}

 */

// Geometric objects in C

typedef struct {
  int length;
  int width;
} rectangle;

typedef struct {
  int length;
} square;


int areaRectangle(rectangle* r) {
  return r->length * r->width;
}

int areaSquare(square* s) {
  return s->length * s->length;
}


// Generic representation

typedef struct {
  void* obj;
  int (*area)(void*); // Function pointer
} shape;


// Generic function
int sumArea(shape s1, shape s2) {
  return s1.area(s1.obj) + s2.area(s2.obj);
}

// Generic functionc (same as above)
int sumArea2(shape s1, shape s2) {
  return (*(s1.area))(s1.obj) + s2.area(s2.obj);
}

// Points to note.
// In modern C, there's no need to dereference a function pointer.
// "." binds tighter than "*".
// Hence, the expression
//     (*(s1.area))(s1.obj)
// is equivalent to
//     s1.area(s1.obj)

// Some examples
void testShape() {
  rectangle r = {1,2};
  square s = {3};
  shape s1 = {&r, (int (*)(void *))(&areaRectangle)};
  shape s2 = {&s, (int (*)(void *))(&areaSquare)};
  shape s3 = {&s, (int (*)(void *))(&areaRectangle)};   // (P)
  shape s4 = {&r, (int (*)(void *))(&areaSquare)};      // (Q)

  printf("\n %d", sumArea(s1,s2));

  printf("\n %d", sumArea(s3,s4));
}

/*

Points to note.

We emulate here "OO" in C. The user needs to precisely follow some coding guidelines.

Consider (P) and (Q).
The "object" (structure) does not match the "method" (function).
The coding guidelines for emulating OO in C are broken.
This may lead to some run-time errors.

*/


int main() {
  testShape();
}

// Sichtbarkeitsbereiche.
// Strings und IO.
// Referenzübergabe

#include <stdio.h>
#include <iostream>
#include <string>
using namespace std;


// Sichtbarkeitsbereiche ("scope")
// In C gibt es nur 2 Sichtbarkeitsbereiche.
// (Im neusten C Standard gilt die gleiche Regel wie in C++)
// In C++ sind beliebige Schachtelungen moeglich.
// Jeder Codeblock { ... } entspricht einem Sichtbarkeitsbereich.

void scopeInC() {
  float i = 1.0;
  int x[5] = {1,2,3,4,5};
  int i_2;
  int j;
  int x_3;

  for(i_2 = 0; i_2 < 5; i_2++) {
    j = x[i_2];
    x_3 = j;
    printf("%d",x_3);
  }

}

// B = Begin. E = End.
// Markiert Codeblock.
void scopeInCPP() { // B1
  float i = 1.0;
  int x[5] = {1,2,3,4,5};

  for(int i=0; i < 5; i++) { // B2
    int j = x[i];
    { // B3
      int x = j;
      printf("%d", x);
    } // E3
  } // E2

} // E1

// Strings.
// IO in C++ ist statisch Typsicher Dank überladener Operatoren/Funktionen


void IO_in_CPP() {
  string s = "\nHallo";

  // Sende String zur Konsole.
  cout << s;

  float f = 1.0;
  // Entspricht printf("%f",f)
  cout << f;

  int i = 5;
  // Entspricht printf("%d",i)
  cout << i;

  // "<<" ist ein binaerer Operator. Links ist das Ausgabeziel und rechts der Ausgabewert.
  // "<<" ist ueberladen, auf der rechten Seiten koennen int, float, .... Werte stehen.


  // Sequenz von Ausgaben.
  cout << f << "  " << i;


  // "<<" ist links assoziativ.
  ((cout << f) << "  ") << i;
  // Beobachtung:
   // cout << f, rechter Operand ist vom Typ float.
  // (...) << "  ",  rechter Operand ist vom Typ string.
  // (...) << i, rechter Operand ist vom Typ int.

  cout << i << "Hallo" << f;

  ((cout << i) << f) << i << f << "Hallo";
}



// Referenzübergabe.
// Syntaktischer Zucker in C++.


struct Pair {
  int left;
  int right;
};

// Variante 1.
void swapPair_Ref(struct Pair& p) {
  int tmp = p.left;
  p.left = p.right;
  p.right = tmp;
}

// Variante 2.
void swapPair_Pointer(struct Pair* p) {
  int tmp = p->left;
  p->left = p->right;
  p->right = tmp;
}


void testSwap() {
  struct Pair p = {1,2};
  struct Pair q = {1,2};

  cout << "\nPair: (" << p.left << "," << p.right << ")";
  swapPair_Ref(p);
  cout << "\nPair swapped: (" << p.left << "," << p.right << ")";

  cout << "\nPair: (" << q.left << "," << q.right << ")";
  swapPair_Pointer(&q);
  cout << "\nPair swapped: (" << q.left << "," << q.right << ")";

}



int main() {

  // scopeInC();
  // scopeInCPP();
  // IO_in_CPP();
  // testSwap();

}

// C++ unterstuetzt überladene Operatoren/Funktionen.
// Regel:
// Instanz muss eindeutig bestimmbar sein via Argumenttypen.

#include <stdio.h>
#include <iostream>
#include <string>
using namespace std;



// Eigene Instanz fuer "<<" Operator.
// Man spricht hier von "Überladung".
struct Pair {
  int left;
  int right;
};


ostream& operator<< (ostream &out, struct Pair &p) {
  out << "(" << p.left << "," << p.right << ")";

  return out;
}


// Transformation des Compilers.
// Generiere eindeutigen Namen, normalerweise Hash-Index
// basierend auf Argumenttypen.
// Wir verwenden einfach "_Pair".

ostream& outStream_Pair (ostream &out, struct Pair &p) {
  out << "(" << p.left << "," << p.right << ")";

  return out;
}


void IO_in_CPP() {
  string s = "\nHallo";

  struct Pair p = {1,2};
  cout << p;   // Verwende obige "out stream" Instanz.
  // Compiler Transformation.
  // Verwende eindeutigen Funktionsaufruf.
  outStream_Pair(cout,p);

}



// Beachte:
//  - swapPair ist eine überladene Funktion.
//  - Mehrfache Definition, aber für verschiedene Argumenttypen.

// Variante 1.
void swapPair(struct Pair& p) {
  int tmp = p.left;
  p.left = p.right;
  p.right = tmp;
}

// Intern passiert folgendes.

// Annahme, der Funktionsname swapPair_Ref ist eindeutig.
void swapPair_Ref(struct Pair& p) {
  int tmp = p.left;
  p.left = p.right;
  p.right = tmp;
}

// Weitere Transformation.
// Uebersetze call-by-reference in call-by-value + pointer

void swapPair_Ref_Transformed(struct Pair* p) {
  int tmp = p->left;
  p->left = p->right;
  p->right = tmp;
}

// Variante 2.
void swapPair(struct Pair* p) {
  int tmp = p->left;
  p->left = p->right;
  p->right = tmp;
}

void swapPair_Pointer(struct Pair* p) {
  int tmp = p->left;
  p->left = p->right;
  p->right = tmp;
}

// Variante 3 (call-by-value)
/*

"'swapPair' is ambiguous"


void swapPair(struct Pair p) {
  int tmp = p.left;
  p.left = p.right;
  p.right = tmp;
}

*/


void testSwap() {
  struct Pair p = {1,2};
  struct Pair q = {1,2};

  cout << "\nPair: " << p;
  swapPair(p);
  // Compiler verwendet hier Variante 1 mit explizitem eindeutigem Namen.
  // 1ter Transformationsschritt.
  swapPair_Ref(p);
  // 2ter Transformationsschritt.
  swapPair_Ref_Transformed(&p);
  cout << "\nPair swapped: " << p;

  cout << "\nPair: " << q;
  swapPair(&q);
  swapPair_Pointer(&q);
  cout << "\nPair swapped: " << q;

}


int main() {

    testSwap();

}

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

// Klassen.
// Erweiterung der Klassenhierarchie ("extends").


///////////////////////
// Klassen

class Point2D {
  float x, y; // private
public:
  Point2D(float x2=0, float y2=0) {
  x = x2;  y = y2;
  }
  void scale(float f) {
  x = f * x; y = f * y;
 }
  float getX() { return x; }
  float getY() { return y; }
  void setXY(float x2, float y2) {
    x = x2; y = y2;
  }

  string show() {

    // + Konkatenation zweier Strings.
    // Konvertierung von float nach String via to_string.
    // C++ unterstuetzt Ueberladung (overloading).
    // D.h wir koennen z.B. to_string auf Werte vom Typ float,
    // als auch auf Werte vom Typ int anwenden.
    // Konkret.
    // string str = to_string(1) + to_string(1.0);
    return ("\nx = " + to_string(x) + "\ny = " + to_string(y));

  }

}; // Point2D


void testPoint2D() {
  Point2D p1; // Wir haben den Default Auruf
              // p1 = Point2D();
              // Aber wir haben Default Werte definiert.
              // Deshalb wir obige Anweisung interpretiert als
              // p1 = Point2D(0,0);
  Point2D p2 = Point2D(1,2);
  Point2D p3(3,4); // Verschieden Schreibweise fuer einen Konstruktoraufruf.
  Point2D p4 = Point2D(1); // Point2D(1,0)

  // Beachte. In Java werden Objekte immer mit Hilfe von "new" angelegt!
  // In Java liegen alle Objekte auf dem Heap.
  // In C++ koennen Objekte auf dem Stack ("kein new") oder dem Heap ("new") liegen.
  // Im obigen Beispiel, liegen die Objekte p1, p2 und p3 auf dem Stack.

  cout << p1.show();
  cout << p2.show();
  p3.scale(2);
  cout << p3.show();
}



// Erweiterung der Klassenhierarchie ("extends").
class Point3D : public Point2D {
  float z;
public:
  Point3D(float x2=0, float y2=0, float z2=0) : Point2D(x2,y2) {
    z = z2;
  }

  void scale(float f) {
    this->setXY(f * this->getX(), f * this->getY());
    z = f * z;
 }

  string show() {
    return ("\nx = " + to_string(getX())
      + "\ny = " + to_string(getY())
      + "\nz = " + to_string(z));

  }

};

void testPoint3D() {
  Point3D p = Point3D(1,2,3);

  cout << p.show();

  p.scale(2);

  cout << p.show();

  // Point3D <= Point2D,
  // bedeutet jedes Objekt der Klasse Point3D kann auch an einer Stelle verwendet werden,
  // an welcher ein Objekt der Klasse Point2D erwartet wird.
  Point2D q = p;

  cout << q.show();

}


int main() {
  testPoint2D();
  testPoint3D();
}

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

// 1. Virtuelle versus nicht-virtuelle Methoden.
// Virtuelle Methoden
//    => dynamische Methodenauswahl basierend
//       auf dem dynamischen Typ des Objekts
//       zur Laufzeit.
//       In C++ muss zur virtuellen Methodenauswahl,
//       der Methodenaufruf via "pointer objects" stattfinden.
// Nicht-virtuelle Methoden
//    => statische Methodenauswahl basierend
//       auf dem statischen Typ wie deklariert
//       im Programmtext.
// 2. "static"
//   Variablen, Methoden welchen von allen
//   Objekten geteilt werden.

class Vehicle {
public:
  static int number;
  static int getNo() { return number; }
  virtual int maxSpeed() { return 0; }
  string info() { return "I'm a vehicle"; }
};

int Vehicle::number = 0;

// car <= Vehicle
class car : public Vehicle {
public:
  car() { Vehicle::number++; }
  int maxSpeed() { return 100; }
  string info() { return "I'm a car"; }
};


// Bike <= Vehicle
class Bike : public Vehicle {
public:
  Bike() { number++; }
  int maxSpeed() { return 30; }
  string info() { return "I'm a bicycle"; }
};


void test1(Vehicle v) {
  cout << "\nInfo: " << v.info();
  cout << "\nSpeed: " << v.maxSpeed();
}

void test2(Vehicle* v) {
  cout << "\nInfo: " << v->info();
  cout << "\nSpeed: " << v->maxSpeed();
}

void test3(car v) {
  cout << "\nInfo: " << v.info();
  cout << "\nSpeed: " << v.maxSpeed();
}


int main() {
  Vehicle::number = 0;
  Bike b = Bike();
  car c = car();

     test1(c); // car <= Vehicle
               // das car Objekt c wird konvertiert
               // in ein Vehicle Objekt

     test2(&c); // *car <= *Vehicle
                // Die Referenz auf ein car Objekt
                // wird uebergeben.

     test3(c);

     test1(b);
     test2(&b);

  cout << "\n There are "
       // << Vehicle::number
       << Vehicle::getNo()
       << " vehicles";
}

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


// Method chaining
class Integer {
  int x;
public:
  Integer(int _x=0) { x = _x; }
  Integer div(int y) {
    return Integer(this->x / y);
  }
  string show() {
    return to_string(this->x);
  }
};


void testInteger() {
  Integer i(20);

  cout << i.div(2).div(4).show();

  // Method calls sind rechts-assoziativ.
  cout << ((i.div(2)).div(4)).show();


  // Was ist im Fall von "division by zero"?
  // Propagiere Fehler via "monadic interface".
  // Mehr Details gegen Ende der Vorlesung.
}

int main() {
  testInteger();
}

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


//////////////////////////////////////////////////
// Abstrakte Klasse = Interface a la Java.

class Shape {
public:
  virtual int area()=0;

};

// Klassendeklaration impliziert die Subtyp Relation  Rectangle <= Shape.
// "<=" ist eine partielle Ordnung abgleitet aus den Klassendeklarationen.
class Rectangle : public Shape {
  int length;
  int width;
public:
  Rectangle(int l=2, int w=3) {
    length = l;
    width = w;
  }

  // Definition fuer Rectangle Objekte.
  int area() { return length * width; }
};


class Square : public Shape {
  int length;
public:
  Square(int l=3) {
    length = l;
  }

  int area() { return length * length; }
};


// Virtuelle Methoden muessen via "pointer objects" aufgerufen werden.
int sumArea(Shape* s1, Shape* s2) {
  return s1->area() + s2->area();

}

void testShape() {
  Rectangle r = Rectangle();
  Square s = Square();

  // Beobachtung:
  // Rectangle <= Shape
  // Also gilt auch
  // Rectangle* <= Shape*
  cout << sumArea(&r,&s);
}

int main() {
  testShape();
}

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


///////////////////////////////
// Templates.
// Expansion zur Compile-Zeit.


// Beispiel: Templatifizierte Funktion
//
// Uebergabe via Referenz.
// Vertausche jeweils die beiden Argumente.

template<typename A>
void mySwap(A& x, A& y) {
  A tmp;

  tmp = x;
  x = y;
  y = tmp;
}


void testSwap() {
  int x = 1;
  int y = 2;
  cout << "\n x = " << x << " y = " << y;

  mySwap<int>(x,y);         // Aufruf fuer die Typinstanz "int"

  cout << "\n x = " << x << " y = " << y;

}


// Beispiel: Templatifizierte Funktion mit verschiedenen Instanzen.

template<typename A>
string Show(A);

template<>
string Show(float x) {
  return to_string(x);
}

template<>
string Show(int x) {
  return to_string(x);
}

template<>
string Show(bool x) {
  return x ? "true" : "false";
}

// Beispiel: Templatifizierte Klasse.

template<typename A, typename B>
class Point {
  A x;
  B y;
public:
  Point(A x2, B y2) {
    x = x2; y = y2;
  }

  string show() {
    return ("\nx = " + Show<A>(x) + "\ny = " + Show<B>(y));
  }

};


void testTemplate() {
  cout << "\n" << Show<int>(1);
  cout << "\n" << Show<float>(1.0);
  cout << "\n" << Show<bool>(true);


  Point<int,float> p = Point<int, float>(1, 3.0);

  cout << "\n" << p.show();


}


int main() {
  testSwap();
  testTemplate();
}

#include <iostream>
#include <string>
#include <memory>
using namespace std;



// delete zu wenig
/////////////////////////////////////////////////////////////

void ex1() {

  string* p = new string("Hallo");

  cout << *p;

  // Oops!
  // delete p;
}


// delete zu viel
/////////////////////////////////////////////////////////////

void ex2() {

  string* p = new string("Hallo");

  cout << *p;

  // Oops!
  delete p;
  delete p;
}

// Zugriff nach delete
/////////////////////////////////////////////////////////////

void ex2b() {

  string* p = new string("Hallo");

  delete p;

  // Oops!
  cout << *p;

}


// Smart Resource Acquisition Is Initialization (RAII)
/////////////////////////////////////////////////////////////

template<typename T>
class Ptr {
  T* ptr;
public:
  Ptr(T x) {
    ptr = new T(x);
  }
  ~Ptr() {
    delete ptr;
    cout << "deleted";
  }
  T operator*() {
    return *ptr;
  }
};

void ex3() {
  Ptr<string> p("Hallo"); // "new"

  cout << *p;
  // Cool!
  // Derefernzierungsoperator kann "overloaded" werden.
  // Der Programmcode
  //    cout << *p;
  // wird vom Compiler uebersetzt nach
  //    cout << *p.ptr;
}
/*
Bei Ruecksprung.
1. Gebe Speicher belegt von p frei.
2. => Konsequenz ist, der Destruktoraufruf auf p.
3. => delete p.ptr

 */



// Kopieren mit Zeigern.
/////////////////////////////////////////////////////////////

void f(Ptr<string> q) {
  cout << *q;
}


void ex4() {
  Ptr<string> p("Hallo");
  f(p); // Default Kopierkonstruktor!
  // q.ptr = p.ptr
  // Zweifaches delete der gleichen Speicherstelle!
}



// RAII + copy Semantik
/////////////////////////////////////////////////////////////

template<typename T>
class Ptr2 {
  T* ptr;
public:
  Ptr2(T x) {
    ptr = new T(x);
  }
  Ptr2(const Ptr2& src) {
    // Standard Definition: ptr = src.ptr;

    ptr = new T(*src.ptr);
    // Wegen "const" koennen wir nicht (einfacher) schreiben:
    // ptr = new T(*src);
  }
  Ptr2& operator=(const Ptr2& src) {
    if(this != &src) {
      delete ptr;
      ptr = new T(*src.ptr);
    }
    return *this;
  }
  ~Ptr2() {
    delete ptr;
    cout << "deleted";
  }
  T operator*() {
    return *ptr;
  }
};


void h(Ptr2<string> q) {
  cout << *q;
}


void ex5() {
  Ptr2<string> p("Hallo");
  Ptr2<string> q("abc");
  h(p);
  p = q;
  h(p);
  // Wir kopieren dauernd!
}

// RAII + copy/move Semantik
/////////////////////////////////////////////////////////////

template<typename T>
class Ptr3 {
  T* ptr;
public:
  Ptr3(T x) {
    ptr = new T(x);
  }
  Ptr3(const Ptr3& src) {
    ptr = new T(*src.ptr);
  }
  Ptr3(Ptr3&& src) {
    ptr = src.ptr;
    src.ptr = nullptr;
  }
  Ptr3& operator=(const Ptr3& src) {
    if(this != &src) {
      delete ptr;
      ptr = new T(*src.ptr);
    }
    return *this;
  }
  Ptr3& operator=(Ptr3&& src) {
    if(this != &src) {
      delete ptr;
      ptr = src.ptr;
      src.ptr = nullptr;
    }
    return *this;
  }
  ~Ptr3() {
    delete ptr;
    cout << "deleted";
  }
  T operator*() {
    return *ptr;
  }
};

void g(Ptr3<string> q) {
  cout << *q;
}


void ex6() {
  Ptr3<string> p("Hallo");
  Ptr3<string> q("abc");
  g(p);                      // copy
  g(Ptr3<string>("123"));    // move
  p = move(q);               // expliziter move
  g(p);
  // g(q);                   // Auf q sollte nicht mehr zugegriffen werden
}


// smart pointers (clevere Bibliothek welche die copy/move Semantik umsetzt)
/////////////////////////////////////////////////////////////

void i(shared_ptr<string> q) {
  cout << *q;
}

// Recast von ex6 mit Hilfe von smart pointers.
void ex7() {
  shared_ptr<string> p = make_shared<string>("Hallo");
  i(p);
  shared_ptr<string> q = p;
  i(q);
  i(make_shared<string>("123"));
  p = move(q);
  i(p);
  // i(q);
}

int main() {

  // ex1();
  // ex2(); // seg fault
  // ex2b();
  // ex3();
  // ex4(); // seg fault
  // ex5();
  // ex6();
  ex7();
}