• Pointer
• Dynamischer Speicher
• sizeof
• Strukturen
• File I/O
• Pipes
• Gruppenbeispiel

• 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>;

• Wird zur Laufzeit angefordert
• Hat keinen »Namen«, nur eine Adresse → Zugriff über Pointer
• Angeforderter Speicher muss auch wieder freigegeben werden
• void* malloc(size_t size) fordert Speicher der Größe size an (in Bytes angegeben)
• void free(void* ptr) gibt angeforderten Speicher wieder frei
• void* realloc(void* ptr, size_t new_size) vergrößert einen angeforderten Speicherbereich

• 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

• Tool zum Finden von
  • Memory Leaks
  • unitialiserten Variablen
  • Off-by-one Fehlern
  • Segmentation Faults
• Testsystem verwendet Valgrind → Valgrind Fehler geben Punkteabzug!
• Nur für Linux, aber auf Pluto schon installiert

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

int main()
{
  char* text = (char*)malloc(6 * sizeof(char));
  strcpy(text, "Hallo!");
  printf("%s\n", text);
  return 0;
}

gcc -Wall -g -o valgrind_test valgrind_test.c

valgrind --leak-check=full ./valgrind_test

• Beispiel 1
• Beispiel 2
• Beispiel 3
• Beispiel 4
• Beispiel 5
• Beispiel 6

• Pointer auf NULL initialisieren
• Pointer nach free auf NULL setzen
• malloc/realloc auf NULL überprüfen
• Bei realloc Hilfspointer verwenden:

  char* text = (char*)malloc(8 * sizeof(char));
  char* new_text = (char*)realloc(text, 16 * sizeof(char));
  if(new_text != NULL)
  {
    text = new_text;
  }
  else
  {
    free(text);
    printf("Out of memory!\n");
  }
  

• Operator (keine Funktion), nur für Größen, die zur Kompilierzeit bekannt sind

• Soll bei malloc/realloc verwendet werden, da diese die Größe in Byte verlangen
• Beispiel: Integer Array mit 10 Elementen
• Falsch

  int* x = (int*)malloc(10);
  

• Richtig

  int* x = (int*)malloc(10 * sizeof(int));
  

• Zusammenfassung mehrer Variablen zu neuem Datentyp
• Zugriff mit ».« bzw. »->« bei Pointern

• #include <stdio.h>
  struct _Person_ {
    char* name;
    int age;
  };
  
  int main()
  {
    struct _Person_ petra;
    petra.name = "Petra";
    petra.age = 17;
    return 0;
  }
  

• Kürzere Schreibweise mit typedef:

  [...]
  
  struct _Person_ {
    char* name;
    int age;
  };
  typedef struct _Person_ Person;
  
  [...]
  
  Person petra;
  petra.name = "Petra";
  petra.age = 17;
  
  [...]
  

• Strukturen können ebenso wie andere Daten dynamisch angelegt werden

• [...]
  struct _Person_ {
    char* name;
    int age;
  };
  typedef struct _Person_ Person;
  
  [...]
  Person* petra = (Person*)malloc(sizeof(Person));
  petra->name = "Petra";
  petra->age = 17;
  
  [...]
  free(petra);
  

• Struktur kann Pointer auf Objekte vom eigenem Typ enthalten

• struct _Person_ {
    char* name;
    int age;
    struct _Person_* father;
    struct _Person_* mother;
  };
  

• Funktioniert, da Pointer immer gleich groß sind (4 bzw. 8 Byte)
• Für viele Datenstrukturen benötigt (z.B. Baum, Linked List)

• Textdateien und Binärdateien
• Textdateien
  • enthalten nur Text
  • können mit dem normalen Editor gelesen werden
  • z.B. .txt Dateien
• Binärdateien
  • enthalten beliebige binäre Daten
  • sind nicht mit dem normalen Editor lesbar
  • z.B. Bilder, Musik

• Datei öffnen

  • fopen(const char * filename, const char * mode);

  • read
  • write
  • append
• Daten lesen

  • fread(void * dst, size_t size, size_t items, FILE * file); 

• Daten schreiben

  •  fwrite(const void * data, size_t size, size_t items, FILE * file); 

• structs können in Binärdateien gespeichert werden

• [...]
  struct _Phone_ {
    int country_code;
    int number;
  }__attribute__((packed));
  
  [...]
  struct _Phone_ number;
  number.number = 1234567;
  number.country_code = 43;
  
  FILE* file = fopen("phone_numbers", "wb"); // wb = write binary
  fwrite(&number, sizeof(struct _Phone_), 1, file);
  fclose(file);
  

• structs können aus Binärdateien geladen werden

• [...]
  struct _Phone_ {
    int country_code;
    int number;
  }__attribute__((packed));
  
  [...]
  struct _Phone_ number;
  
  FILE* file = fopen("phone_numbers", "rb"); // rb = read binary
  fread(&number, sizeof(struct _Phone_), 1, file);
  fclose(file);
  

• Integer hat 4 Byte
• Jedes der Bytes kann wie eine »Ziffer« gesehen werden
• Die Umrechung zurück in einen Integer erfolgt dann wie in jedem anderen Zahlensystem
• Achtung Endianness: Intel ist Little-Endian, d.h. die Byte-Reihenfolge ist »verkehrt«
• Beispiel: Integer 0x12345678 (= 305.419.896) in einer Datei: 78 56 34 12

• Inhalt der Datei als char Array eingelesen: 02 01 00 00
• Umrechnung ins Dezimalsystem:

  2560	2561	2562	2563
  02	01	00	00

• = 0x02 * 256⁰ + 0x01 * 256¹ + 0x00 * 256² + 0x00 * 256³
• = 258

• Natürlich, wir lassen den Compiler für uns arbeiten
• Direktes Einlesen in einen Integer mit fread:

  int length;
  fread(&length, sizeof(int), 1, file);

• Über Pointer, indem wir den Speicherinhalt neu »interpretieren« lassen:

  // buffer is the char array containing the file
  int length = *((int*)buffer);

• Mit memcpy in einen Integer kopieren:

  // buffer is the char array containing the file
  int length;
  memcpy(&length, buffer, sizeof(int));

• Keine C Funktion um die Dateigröße zu ermitteln
• Folgende Vorgehensweise:
  1. Dateizeiger an das Ende der Datei setzen
  2. Abfragen, wo der Dateizeiger steht
  3. Dateizeiger wieder auf den Anfang der Datei setzen
• Der Code dazu:

  long size;
  fseek(file, 0, SEEK_END);
  size = ftell(file);
  fseek(file, 0, SEEK_SET);
  

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 $?

• Gut und viel testen!
• Rückgabewerte der File I/O Funktionen prüfen!
• Nie vergessen, bei malloc und realloc auf NULL zu prüfen!
• String-Bibliothek Funktionen anschauen (strtok), es gibt jedoch nicht alle Funktionen die man braucht!
• Codingstandard beachten!
• Valgrind verwenden!

• Programm sinnvoll in Funktionen einteilen
• Aussagekräftige Variablennamen verwenden
• Keine Variablen Recyclen
• Variablen initialisieren
• Lieber zu viele Klammern als zu wenig
• Komplizierte Stellen kommentieren, aber keine unnötigen Kommentare