• HW3: Häufige Fehler
• Palme Testreport Explainer
• Funktionen
• Call-by-Reference
• Arrays
• Pointer
• Strings
• Pipes
• Gruppenbeispiel 1: Besprechung

• Nur eine Schleife verwendet (Spezifikation: zwei Schleifen)
• Codingstandard (Tabulatoren, Zeile zu lang, Einrückungen, ...)
• Deutsche Variablennamen und deutsche Kommentare
• Schlechte Variablennamen (i, tmp, ...)
• Falsche Overflow Behandlung
• Falsche Outputs

• Falsche Overflow Behandlung:

  • if(number < 0) ...

  • if((number * counter) < number) ...

  • if(number > INT_MAX - number) ...

  • if(number > INT_MAX) ...

  • if(nubmer * counter >= INT_MAX) ...

• Richtige Overflow Behandlung:

  • if(number > INT_MAX / counter) ...

  • if(((double)number * (double)counter) > INT_MAX) ...

 <Rueckgabewert-Typ> Funktion-Name (<Parameter1>, <Parameter2>...)
 {
   // Code
   return <Rueckgabewert>
 }

 int main()
 {
   // Aufruf:
   <Rueckgabewert-Typ> Ergebnis;
   Ergebnis = Funktion-Name(<Parameter1>, <Parameter2>...);
 } 

Rückgabewert der main-Funktion anzeigen

 > echo $?
 0
 

 int correctCode(int studentID)
 {
   ... code ...
   return points;
 }

 int main()
 {
   int num_studis = 85;
   int i = 0;
   for(i = 0; i < num_studis; i++)
   {
      printf("Student #%d received %d points!", i, correctCode(i));
   }
 } 

 void printHello()
 {
   while(1)
   {
     int studentID = 0;
     printf("Please enter your studentID: ");
     scanf("%d", &studentID);

     if(studentID == 0)
     {
       return;
     }
     printf("Hello %d!\n", studentID);
   }
 }

 int main()
 {
   printHello();
 } 

 int fibonacci(int num, int a, int b)
 {
   if(num == 0)
   {
     return a;
   }
   else
   {
     return fibonacci(num - 1; b, a + b);
   }
 }

 int main()
 {
   int num = 15;
   int fib = fibonacci(num, 0, 1);
   printf("%dth fibonacci number = %d", num, fib);

 } 

• Hintereinander liegende Daten vom gleichen Typ
• Größe kann nicht mehr verändert werden, muss bei Deklaration bekannt sein
• Zugriff über [ ]
• Deklaration:

  <typ> name[<size>];

• Initialisiertes Array:

  <typ> name[] = {<value1>, <value2>, ...};

• Zugriff:

  name[<index>] = <value>;

• Soll ein Array an eine Funktion als Parameter übergeben werden gibt es 3 Wege

1. Array variabler Größe

   void foo(int bar[]) {
    [..]
   }

2. Array fixer Größe

   void foo(int bar[8]) {
    [..]
   }

3. Als Pointer

   void foo(int* bar) {
    [..]
   }

• Arrays können mehrere Dimensionen haben
• 2-dimensionale Arrays:

  <typ> name[<rows>][<columns>];

• Zugriff über Zeilen- und Spaltenindex:

  name[<row>][<column>] = <value>;

• Beispiel Initialisierung:

  char matrix[3][3] = { {'A', 'B', 'C'}, {'D', 'E', 'F'},
        {'G', 'H', 'I'} };

• Ja, in C beliebig viele (so lange wir Speicher haben)
• Schwer vorstellbar ab 4 Dimensionen, deshalb als Array von Arrays denken

int cube[3][3][3];
int hypercube[3][3][3][3];

 int hypercube[3][3][3][3];

Möglichkeit 1: 4D-Würfel

Möglichkeit 2: Array von 3D Würfeln

#include <stdio.h>

void printMatrix3(char matrix[][3])
{
  int y;
  for(y = 0; y < 3; y++)
  {
    printf("%c %c %c\n", matrix[y][0], matrix[y][1], matrix[y][2]);
  }
}

int main()
{
  char matrix[3][3] = { {'A', 'B', 'C'}, {'D', 'E', 'F'},
      {'G', 'H', 'I'} };
  printMatrix3(matrix);
}

• Pointer »zeigen« auf Variablen
• Pointer enthält die Adresse einer Variable
• Deklaration mit "*"

  <datentyp>* name;

• Zugriff auf die Variable durch Dereferenzieren ebenfalls mit "*"

  *name = <value>;

• Zuweisen einer Adresse durch den Adressoperator "&"

  name = &<variable>;

• Bei Funktionsaufruf nicht Variable, sondern Adresse übergeben
• mehrere Rückgabewerte möglich
• z.B. nützlich damit eine Funktion einen Wert sowie einen Fehlercode liefern kann

void getHourMinutes(int minutes, int* h, int* m)
{
  *h = minutes / 60;
  *m = minutes % 60;
}

int main()
{
  int hour = 0, minutes = 0;
  getHourMinutes(320, &hour, &minutes);
  printf("%d:%d\n", hour, minutes);
  return 0;
}

• String = Zeichenkette, »Text«
• String ist nur ein Array von char (Zeichen)
• Strings enden mit einem 0-Byte ('\0', nicht dem Zeichen 0!)
• Deklaration (am häufigsten):

  char* text = "Hallo!";

Andere Varianten:

char text[] = "Hallo!";

char text[] = {'H', 'a', 'l', 'l', 'o', '!', '\0'};

• Funktion strcmp aus string.h verwenden
• == funktioniert nicht, vergleicht nur die Speicheradressen

•  char* str1 = "Hello";
   char* str2 = "World";
   if(strcmp(str1, str2) == 0)
   {
     // strings sind gleich
   }
   else
   {
     // strings sind ungleich
   }
  

• Zugriff durch Array-Schreibweise ([])
• Erstes Zeichen hat Index 0!
• Letztes Zeichen ist 0-Byte ('\0')

•  char* str1 = "Hello";
   char c1 = str1[0]; // c1 = 'H'
   char c2 = str1[4]; // c2 = 'o'
   char c3 = str1[5]; // c3 = '\0'
  

• Weitere Funktionen die mit Strings arbeiten in string.h
• http://www.cplusplus.com/reference/cstring/
• Einbinden mit

  #include <string.h>

• Nützliche Funktionen:

  strlen

  Länge des Strings (ohne 0-Byte!)

  strcpy

  String in einen anderen kopieren

  strcat

  Strings aneinanderhängen

  sprintf

  Wie printf, aber Ausgabe wird in String gespeichert

Möglichkeit, die Ausgabe der einzelnen Befehle umzuleiten bzw. an andere Befehle weiterzuleiten.

• Umleiten der Ausgabe in Datei
• Standardeingabe von Datei lesen
• Ausgabe als Eingabe für anderes Programm

Ausgabe umleiten

./programm > ausgabe.txt

Eingabe umleiten

./programm < eingabe.txt

stderr umleiten

./programm 2> error.txt

Beliebig kombinierbar

./programm < input.txt 1> output.txt 2> error.txt

Stdout als stdin eines anderen programms

./programm | tail

Returncode des letzten Programms

echo $?