C: Spickzettel

1. Was ist C?

• C ist kompiliert, schnell und hardwarenah, ohne Garbage Collector
• Präprozessor → Compiler → Linker erzeugen das Programm
• Immer mit -Wall -Wextra übersetzen
• Startpunkt ist int main(void); return 0 heißt Erfolg
• Du bist für Speicher und Sicherheit selbst verantwortlich

gcc -Wall -Wextra -std=c17 -o hallo hallo.c
./hallo

2. Aufbau eines C-Programms

• Aufbau: #include, Prototypen, main, Funktionsdefinitionen
• Der Compiler liest von oben nach unten: erst deklarieren, dann benutzen
• printf mit Platzhaltern (%d, %f, %s, %c); sie müssen zum Typ passen
• -Wall -Wextra immer einschalten, Warnungen beheben
• Rückgabewert von main meldet Erfolg (0) oder Fehler

#include <stdio.h>          /* Präprozessor: Header einbinden */

#define MAX 3               /* Makro: wird vor dem Übersetzen ersetzt */

// Funktionsprototyp (Deklaration)
int quadrat(int x);

int main(void) {
    for (int i = 1; i <= MAX; i++) {
        printf("%d zum Quadrat ist %d\n", i, quadrat(i));
    }
    return 0;
}

// Funktionsdefinition
int quadrat(int x) {
    return x * x;
}

3. Variablen und Datentypen

• Typen: char, int, long long, float, double, bool, unsigned; feste Größen aus <stdint.h>
• sizeof liefert die Größe in Bytes
• Ganzzahldivision schneidet ab; 7 / 2.0 rechnet als Kommazahl
• Vorzeichenbehafteter Überlauf ist undefiniertes Verhalten
• Variablen immer initialisieren; const statt Magic Numbers
• static lokal behält den Wert zwischen Aufrufen

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <limits.h>

int main(void) {
    int alter = 17;
    unsigned int zaehler = 3000000000u;
    long long gross = 9000000000LL;
    double pi = 3.14159265358979;
    char buchstabe = 'A';
    bool fertig = true;
    uint8_t byte = 255;

    printf("%d %u %lld %.5f %c %d %d\n", alter, zaehler, gross, pi, buchstabe, fertig, byte);
    printf("Größen: char %zu, short %zu, int %zu, long %zu, long long %zu, double %zu, Zeiger %zu\n",
           sizeof(char), sizeof(short), sizeof(int), sizeof(long), sizeof(long long), sizeof(double), sizeof(void *));
    printf("INT_MAX = %d, INT_MIN = %d\n", INT_MAX, INT_MIN);
    return 0;
}

4. Operatoren und Ausdrücke

• 0 ist falsch, alles andere wahr; Vergleiche liefern 1 oder 0
• = ist Zuweisung, == Vergleich; Compiler-Warnungen aktivieren
• Bits: &, |, ^, ~, <<, >> für Flags und Masken
• Bei gemischten Operatoren Klammern setzen
• Pro Anweisung höchstens eine Änderung derselben Variable
• Vorzeichenbehaftet/-los nicht mischen

#include <stdio.h>

int main(void) {
    int a = 17, b = 5;
    printf("%d %d %d %d %d\n", a + b, a - b, a * b, a / b, a % b);
    printf("%d %d %d\n", a > b, a == b, !(a > b));
    printf("%d %d\n", a > 10 && b < 3, a > 10 || b < 3);
    int i = 5;
    int alt = i++;                       // erst benutzen, dann erhöhen
    int neu = ++i;                       // erst erhöhen, dann benutzen
    printf("%d %d %d\n", alt, neu, i);
    int x = 10;
    x += 5; x *= 2; x -= 1; x /= 3; x %= 7;
    printf("%d\n", x);
    printf("%d\n", a > b ? a : b);
    return 0;
}

5. Ein- und Ausgabe

• Ausgabe: printf, puts, fprintf(stderr, ...); Pufferausgabe mit snprintf
• Eingabe: Zeile mit fgets lesen, dann mit sscanf/strtol/strtod auswerten
• Rückgabewerte von scanf immer prüfen; bei %s Breite angeben
• Nie gets benutzen
• EOF ist ein int: Variable mit int deklarieren

#include <stdio.h>

int main(void) {
    puts("Hallo");
    putchar('X'); putchar('\n');
    fprintf(stderr, "Das geht an stderr\n");
    char puffer[50];
    int n = snprintf(puffer, sizeof puffer, "%s hat %d Punkte (%.1f%%)", "Mia", 42, 87.5);
    printf("%s [%d Zeichen]\n", puffer, n);
    return 0;
}

6. Bedingungen und Schleifen

• 0 ist falsch, alles andere wahr; immer { } setzen
• switch für Ganzzahlen, break nicht vergessen
• for für Zählschleifen, while für Bedingungen, do-while läuft mindestens einmal
• break beendet, continue überspringt; goto nur selten
• Ein ; hinter der Schleife ist ein klassischer Fehler

#include <stdio.h>

int main(void) {
    int punkte = 73;
    if (punkte >= 90) {
        puts("sehr gut");
    } else if (punkte >= 75) {
        puts("gut");
    } else if (punkte >= 50) {
        puts("bestanden");
    } else {
        puts("nicht bestanden");
    }

    int x = 0;
    if (x) puts("wahr"); else puts("falsch (0 ist falsch)");
    const char *text = "";
    if (text && text[0]) puts("nicht leer"); else puts("leer");
    return 0;
}

7. Funktionen

• Rückgabetyp name(Parameter); void für "nichts"
• Argumente werden kopiert; für Änderungen übergibst du Zeiger (&x, *p)
• Mehrere Ergebnisse: Zeiger oder struct
• Rekursion braucht eine Abbruchbedingung
• Funktionszeiger ermöglichen Callbacks (qsort)
• static bei Funktionen macht sie dateilokal

#include <stdio.h>

int addiere(int a, int b) {
    return a + b;
}

void gruss(const char *name) {
    printf("Hallo %s!\n", name);
}

double mittelwert(double a, double b) { return (a + b) / 2; }

int main(void) {
    printf("%d\n", addiere(3, 4));
    gruss("Mia");
    printf("%.1f\n", mittelwert(3, 4));
    return 0;
}

8. Arrays und Strings

• Arrays: feste Größe, Index ab 0, keine Grenzprüfung
• Beim Übergeben wird ein Array zum Zeiger; die Länge übergibst du extra
• Ein String ist ein char-Array mit abschließendem '\0'
• Strings mit strcmp vergleichen, mit snprintf sicher zusammensetzen
• strcpy/strcat/gets können Puffer überlaufen lassen
• Zahlen aus Text: strtol/strtod statt atoi/atof

#include <stdio.h>

int main(void) {
    int z[5] = {10, 20, 30};              // Rest wird 0
    int auto_groesse[] = {1, 2, 3, 4};    // Größe 4 erkannt
    int n = sizeof auto_groesse / sizeof auto_groesse[0];
    printf("%d %d %d %d\n", z[0], z[2], z[4], n);
    z[1] = 99;
    for (int i = 0; i < 5; i++) printf("%d ", z[i]);
    printf("\n");

    int matrix[2][3] = { {1, 2, 3}, {4, 5, 6} };
    printf("%d %zu %zu\n", matrix[1][2], sizeof matrix / sizeof matrix[0], sizeof matrix[0] / sizeof matrix[0][0]);
    return 0;
}

9. Zeiger

• Ein Zeiger speichert eine Adresse: &x holt sie, *p greift darauf zu
• NULL heißt "nichts"; vor Zugriff prüfen
• Array-Name ≈ Zeiger auf das erste Element; p[i] ist *(p + i)
• Zeigerarithmetik rechnet in Elementgrößen
• const int *p schützt die Daten; void * ist ein typloser Zeiger
• Nie Zeiger auf lokale Variablen zurückgeben

#include <stdio.h>

int main(void) {
    int zahl = 42;
    int *p = &zahl;              // p speichert die Adresse von zahl
    printf("Wert: %d, Zeiger zeigt auf: %d\n", zahl, *p);
    *p = 100;                    // Wert über den Zeiger ändern
    printf("zahl ist jetzt %d\n", zahl);
    printf("gleiche Adresse: %d\n", p == &zahl);
    printf("Größe des Zeigers: %zu Byte\n", sizeof p);
    return 0;
}

10. Strukturen, Enums und Unions

• struct bündelt Felder; Zugriff mit . bzw. -> bei Zeigern
• typedef gibt Typen kürzere Namen; Strukturen lassen sich kopieren und per Zeiger übergeben
• enum für benannte Ganzzahl-Konstanten; union teilt sich einen Speicherplatz
• Füllbytes machen Strukturen oft größer, als die Felder vermuten lassen
• Verkettete Strukturen entstehen mit Zeigern auf den eigenen Typ

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

struct Person {
    char name[32];
    int alter;
    double gewicht;
};

int main(void) {
    struct Person mia = { "Mia", 17, 58.5 };
    struct Person tom = { .name = "Tom", .alter = 19 };      // benannte Initialisierung, Rest = 0
    mia.alter++;
    strcpy(tom.name, "Tom K.");
    printf("%s %d %.1f\n", mia.name, mia.alter, mia.gewicht);
    printf("%s %d %.1f\n", tom.name, tom.alter, tom.gewicht);
    struct Person kopie = mia;                                // Struktur komplett kopieren
    kopie.alter = 99;
    printf("%d %d\n", mia.alter, kopie.alter);
    printf("Größe: %zu\n", sizeof(struct Person));
    return 0;
}

11. Dynamischer Speicher

• Stack: automatisch und klein; Heap: von Hand mit malloc/free
• malloc prüfen, sizeof *p verwenden, jeden Block genau einmal freigeben
• realloc in eine Hilfsvariable; Zeiger nach free auf NULL
• Fehlerbilder: Leck, doppeltes free, use after free, Überlauf
• AddressSanitizer und Valgrind finden Speicherfehler

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

int main(void) {
    int n = 5;
    int *a = malloc(n * sizeof *a);            // n ints, nicht initialisiert
    if (a == NULL) { fprintf(stderr, "kein Speicher\n"); return 1; }
    for (int i = 0; i < n; i++) a[i] = i * i;

    int *b = calloc(n, sizeof *b);             // n ints, alle 0
    printf("%d %d %d\n", a[4], b[0], b[4]);

    int *c = realloc(a, 10 * sizeof *a);       // Größe ändern (kann verschieben!)
    if (c == NULL) { free(a); free(b); return 1; }
    a = c;
    a[9] = 81;
    printf("%d %d\n", a[4], a[9]);

    free(a);                                   // jeden reservierten Block freigeben
    free(b);
    return 0;
}

12. Dateien lesen und schreiben

• fopen liefert NULL bei Fehlern: immer prüfen; fclose nicht vergessen
• Text: fprintf, fgets, fscanf; Binärdaten: fwrite, fread mit Modus "rb"/"wb"
• Zeilenweise lesen mit fgets und Puffergröße
• perror zeigt den Grund eines Fehlers
• Dateien sind nur Ströme von Bytes; Formate bestimmst du selbst

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

int main(void) {
    const char *pfad = "notiz.txt";

    FILE *f = fopen(pfad, "w");
    if (f == NULL) { perror("fopen"); return 1; }
    fprintf(f, "Zeile %d\n", 1);
    fputs("Zeile 2\n", f);
    fclose(f);

    f = fopen(pfad, "a");                        // anhängen
    if (f) { fputs("Zeile 3\n", f); fclose(f); }

    f = fopen(pfad, "r");
    if (f == NULL) { perror("fopen"); return 1; }
    char zeile[64];
    int nr = 0;
    while (fgets(zeile, sizeof zeile, f) != NULL) {        // zeilenweise lesen
        zeile[strcspn(zeile, "\n")] = '\0';
        printf("%d: %s\n", ++nr, zeile);
    }
    fclose(f);

    FILE *fehlt = fopen("gibt-es-nicht.txt", "r");
    if (!fehlt) perror("Fehler");                    // gibt eine lesbare Meldung aus
    remove(pfad);
    return 0;
}

13. Präprozessor und mehrere Quelldateien

• Der Präprozessor ersetzt Text (#include, #define, #ifdef) vor dem Compiler
• Header (.h) enthalten die Schnittstelle, .c-Dateien die Umsetzung
• Include-Guards verhindern doppeltes Einbinden
• Makros sparsam und mit allen Klammern; besser static inline und const
• make oder CMake bauen größere Projekte automatisch

#include <stdio.h>

#define PI 3.14159
#define QUADRAT(x) ((x) * (x))           // alle Klammern setzen!
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define VERSION "1.2"

#ifdef DEBUG
#define LOG(msg) printf("[DEBUG] %s\n", msg)
#else
#define LOG(msg) ((void) 0)
#endif

int main(void) {
    printf("%.2f %d %d\n", PI * QUADRAT(2), QUADRAT(3 + 1), MAX(4, 9));
    printf("Version %s, Datei %s, Zeile %d\n", VERSION, "x.c", __LINE__);
    LOG("nur mit -DDEBUG sichtbar");
#if defined(__linux__)
    puts("Linux");
#elif defined(_WIN32)
    puts("Windows");
#else
    puts("anderes System");
#endif
    return 0;
}

14. Undefiniertes Verhalten und sicheres C

• Undefiniertes Verhalten ist kein Fehler, der sicher abstürzt, sondern erlaubt dem Compiler alles
• Typische Auslöser: Grenzüberschreitung, NULL/ungültige Zeiger, Überlauf, nicht initialisierte Variablen, use after free
• Puffergrößen immer kennen und prüfen; längenbegrenzte Funktionen nutzen
• -Wall -Wextra, Sanitizer, Valgrind und statische Analyse finden die meisten Fehler früh
• Rückgabewerte prüfen, alles initialisieren, Eingaben nie vertrauen

#include <stdio.h>
#include <limits.h>
#include <stdbool.h>

bool addiere_sicher(int a, int b, int *ergebnis) {
    if ((b > 0 && a > INT_MAX - b) || (b < 0 && a < INT_MIN - b)) return false;
    *ergebnis = a + b;
    return true;
}

int main(void) {
    int r;
    printf("%d\n", addiere_sicher(2000000000, 100000000, &r));    // passt
    printf("%d\n", addiere_sicher(2000000000, 200000000, &r));    // Überlauf
    printf("%d\n", __builtin_add_overflow(INT_MAX, 1, &r));        // GCC/Clang: eingebaute Prüfung
    return 0;
}

15. Nachschlagen: Spickzettel

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

#define LEN(a) (sizeof (a) / sizeof (a)[0])

typedef struct { int id; char name[16]; } Eintrag;

static int nach_id(const void *a, const void *b) {
    return ((const Eintrag *) a)->id - ((const Eintrag *) b)->id;
}

int main(void) {
    // Array-Länge
    int z[] = {4, 8, 15, 16, 23, 42};
    printf("%zu\n", LEN(z));

    // Sortieren und binär suchen
    Eintrag e[] = { {3, "c"}, {1, "a"}, {2, "b"} };
    qsort(e, LEN(e), sizeof e[0], nach_id);
    Eintrag such = { 2, "" };
    Eintrag *treffer = bsearch(&such, e, LEN(e), sizeof e[0], nach_id);
    printf("%s\n", treffer ? treffer->name : "nicht gefunden");

    // Zufallszahl 1..6
    srand((unsigned) time(NULL));
    int w = rand() % 6 + 1;
    printf("%d\n", w >= 1 && w <= 6);

    // String umkehren
    char s[] = "Hallo";
    for (size_t i = 0, j = strlen(s) - 1; i < j; i++, j--) { char t = s[i]; s[i] = s[j]; s[j] = t; }
    printf("%s\n", s);
    return 0;
}