• Bits & Bytes
• Command-line Arguments
• Dynamischer Speicher
• sizeof
• Strukturen
• File I/O
• Pipes
• Ausbesserungsbeispiel

• AND (auf uint8_t)

  • output = output & 0x80;

  • output &= (1 << 7);

• OR (auf uint8_t)

  • output = output | 0x10;

  • output |= (1 << 4);

• XOR (auf uint8_t)

  • output = output ^ 0x01;

  • output ^= (1 << 0);

int main (int argc, char *argv[])
{
  int count;
  printf ("This program was called with \"%s\".\n",argv[0]);

  if (argc > 1)
  {
    for (count = 1; count < argc; count++)
    {
      printf("argv[%d] = %s\n", count, argv[count]);
    }
  }
  else
  {
    printf("The command had no other arguments.\n");
  }
  return 0;
}
  

• 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

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

• 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

#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;
}

clang -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

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

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

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

• [...]
  typedef struct _Person_
  {
    char* name_;
    int age_;
  } 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)

• Zusammenfassung von Bits
• Sinnvoll, wenn Funktion mehr als einen "Zustand" zurückgeben muss

• #include <stdio.h>
  typedef struct _FileParserReturn_
  {
    char file_present_ : 1;
    char file_open_failed_ : 1;
    char ignored_ : 6;
  } FileParserReturn;
  
  FileParserReturn parseConfigFile( ... )
  {
    FileParserReturn return_value;
    
    ...
    return_value.file_present_ = 1;
  
    return return_value;
  }
  

• "Zusammenfassung von #defines"
• Sinnvoll, wenn Funktion mehrere verschiedene Werte zurückgibt

• #include <stdio.h>
  typedef enum _FileParserReturn_
  {
    FILE_PRESENT,
    FILE_OPEN_FAILED
  } FileParserReturn;
  
  FileParserReturn parseConfigFile( ... )
  {
    ...
  
    return FILE_PRESENT;
  }
  

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

• bzw. alle Funktionen, die mit "f" beginnen (z.B. fprintf, fscanf, fgets)

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

• wichtig wenn struct in Datei gespeichert werden soll
• entfernt unnötige Padding-Bytes

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

• Gute Übung!
• Nur abgeben, wenn es benotet werden soll! (+ E-Mail an Tutor)
• Beispiel mit wenigsten Punkten wird ersetzt
• Aber: Punkteverlust möglich!