C Spickzettel

Q: Warum braucht scanf ein Und-Zeichen (&), printf aber nicht?

`scanf` schreibt den Wert in deine Variable zurück, daher braucht es die Adresse der Variable - genau das liefert `&x`. `printf` liest den Wert nur, also übergibst du den Wert selbst. Die Ausnahme sind Strings: Ein `char`-Array zerfällt bereits zu einem Zeiger, also übergibst du `scanf("%s", name)` ohne das `&`.

Zuletzt aktualisiert 27. Mai 2026

Live im C-Playground ausprobieren C kostenlos lernen

Hello World & Programmaufbau

Jedes C-Programm beginnt bei main und gibt ein int zurück.

Element	Code
Einen Header einbinden	`#include <stdio.h>`
Einstiegspunkt	`int main(void) { ... }`
Mit Kommandozeilenargumenten	`int main(int argc, char *argv[]) { ... }`
Eine Zeile ausgeben	`printf("Hello, World!\n");`
Erfolg zurückgeben	`return 0;`
Einzeiliger Kommentar	`// comment`
Blockkommentar	`/* comment */`

Datentypen

Größen sind plattformabhängig; die folgenden Mindestwerte werden vom Standard garantiert.

Typ	Beschreibung
`int`	Ganzzahl, mindestens 16 Bit (meist 32)
`unsigned int`	Nicht-negative Ganzzahl
`long` / `long long`	Breitere Ganzzahlen (mindestens 32 / 64 Bit)
`float` / `double`	Gleitkomma mit einfacher / doppelter Genauigkeit
`char`	Einzelnes Byte, auch für Zeichen verwendet
`_Bool` (`bool` über `<stdbool.h>`)	`true` oder `false`
`size_t`	Vorzeichenloser Typ für Größen und Indizes
`void`	Kein Typ - für Funktionen und generische Zeiger verwendet

printf- & scanf-Formatangaben

Platzhalter, die zum Typ jedes Arguments passen.

Angabe	Passt zu
`%d` / `%i`	Vorzeichenbehaftetes `int`
`%u`	Vorzeichenloses `int`
`%ld` / `%lld`	`long` / `long long`
`%f`	`double` (und `float` in `printf`)
`%.2f`	`double` mit 2 Nachkommastellen
`%c`	Einzelnes `char`
`%s`	String (`char *`)
`%p`	Zeigeradresse
`%x`	Vorzeichenloses `int` in Hexadezimal
`%zu`	`size_t`

Operatoren

Operator	Bedeutung
`+ - * / %`	Arithmetik (`%` ist der ganzzahlige Rest)
`== !=`	Gleich / ungleich
`< > <= >=`	Vergleich
`&& \|\| !`	Logisches und / oder / nicht
`& \| ^ ~ << >>`	Bitweise und, oder, xor, nicht, Verschiebungen
`++ --`	Inkrement / Dekrement
`+= -= *= /=`	Zusammengesetzte Zuweisung
`cond ? a : b`	Ternäre Bedingung
`sizeof(x)`	Größe eines Typs oder einer Variable in Bytes

Kontrollfluss

Anweisung	Syntax
If / else	`if (x > 0) { ... } else { ... }`
Else if	`else if (x == 0) { ... }`
Switch	`switch (n) { case 1: ...; break; default: ...; }`
While-Schleife	`while (i < n) { ... }`
Do-while-Schleife	`do { ... } while (i < n);`
For-Schleife	`for (int i = 0; i < n; i++) { ... }`
Break / continue	`break;` verlässt eine Schleife, `continue;` springt zur nächsten Iteration
Goto (selten)	`goto label;` ... `label:`

Funktionen

Vor der Verwendung deklarieren oder einen Prototyp am Anfang der Datei hinzufügen.

Operation	Syntax
Eine Funktion definieren	`int add(int a, int b) { return a + b; }`
Prototyp (Deklaration)	`int add(int a, int b);`
Kein Rückgabewert	`void greet(void) { ... }`
Keine Parameter	`int rand_seed(void) { ... }`
Übergabe per Zeiger (verändern)	`void inc(int p) { (p)++; }`
Ein Array übergeben	`int sum(int arr[], int n) { ... }`
Static (dateilokal)	`static int helper(void) { ... }`

Zeiger & Speicher

Ein Zeiger hält eine Adresse. Heap-Speicher muss manuell freigegeben werden.

Operation	Syntax
Einen Zeiger deklarieren	`int *p;`
Adresse-von	`p = &x;`
Dereferenzieren (lesen/schreiben)	`int y = p;` / `p = 10;`
Nullzeiger	`int *p = NULL;`
Auf dem Heap reservieren	`int a = malloc(n sizeof(int));`
Reservieren + nullen	`int *a = calloc(n, sizeof(int));`
Eine Reservierung vergrößern	`a = realloc(a, newSize);`
Heap-Speicher freigeben	`free(a);`
Zeigerarithmetik	`*(a + i)` ist dasselbe wie `a[i]`

Arrays & Strings

Strings in C sind char-Arrays, abgeschlossen durch \0.

Operation	Syntax
Ein Array deklarieren	`int nums[5];`
Ein Array initialisieren	`int nums[] = {1, 2, 3};`
Auf ein Element zugreifen	`nums[0] = 10;`
Array-Länge (Stack-Arrays)	`sizeof(nums) / sizeof(nums[0])`
String-Literal	`char s[] = "hello";`
String-Länge	`strlen(s)` (ohne `\0`)
Einen String kopieren	`strcpy(dst, src);`
Strings vergleichen	`strcmp(a, b) == 0` bedeutet gleich
Strings verketten	`strcat(dst, src);`

Structs & gängige stdlib

Operation	Syntax
Ein Struct definieren	`struct Point { int x; int y; };`
Deklarieren & zugreifen	`struct Point p; p.x = 1;`
Zugriff per Zeiger	`p->x = 1;` (entspricht `(*p).x`)
Typalias	`typedef struct Point Point;`
Eingabe lesen	`scanf("%d", &n);`
String in int umwandeln	`int n = atoi("42");`
Absolutwert / Potenz	`abs(x)` (int), `pow(x, y)` aus `<math.h>`
Ein Array sortieren	`qsort(arr, n, sizeof(int), cmp);`

Die C-Syntax, Formatangaben und Zeigermuster, die du am häufigsten brauchst, auf einer Seite. Dieser C-Spickzettel ist eine Schnellreferenz zum Schreiben von C - die Datentypen, printf/scanf-Angaben, Operatoren, der Kontrollfluss sowie die Zeiger- und Speicheroperationen, die viele aus dem Tritt bringen.

Alles hier ist Standard-C (C99/C11) und kompiliert mit gcc oder clang. Kopiere, was du brauchst, oder probiere jeden Codeschnipsel live im C-Playground aus - kein Compiler zu installieren.

C-Spickzettel FAQ

Ist dieser C-Spickzettel kostenlos?

Ja. Dieser C-Spickzettel ist völlig kostenlos, ohne erforderliche Anmeldung. Setze ein Lesezeichen und komm jederzeit wieder, wenn du einen Typ, eine Formatangabe oder eine Zeigeroperation nachschlagen möchtest.

Was ist der Unterschied zwischen Stack und Heap in C?

Stack-Speicher hält lokale Variablen und wird beim Rücksprung einer Funktion automatisch freigegeben - schnell, aber in der Größe begrenzt. Heap-Speicher wird explizit mit malloc oder calloc reserviert, lebt, bis du free aufrufst, und wird verwendet, wenn du Speicher brauchst, der die aktuelle Funktion überdauert oder dessen Größe erst zur Laufzeit bekannt ist. Wenn du vergisst, Heap-Speicher mit free freizugeben, entsteht ein Speicherleck.

Warum braucht scanf ein Und-Zeichen (&), printf aber nicht?

scanf schreibt den Wert in deine Variable zurück, daher braucht es die Adresse der Variable - genau das liefert &x. printf liest den Wert nur, also übergibst du den Wert selbst. Die Ausnahme sind Strings: Ein char-Array zerfällt bereits zu einem Zeiger, also übergibst du scanf("%s", name) ohne das &.

Kann ich C online üben?

Ja. Öffne den C-Playground, um jeden Codeschnipsel aus diesem Spickzettel in deinem Browser zu kompilieren und auszuführen - kein Compiler zu installieren. Wenn du Struktur möchtest, führt dich Coddys kostenloser interaktiver C-Kurs Schritt für Schritt von Variablen und Schleifen zu Zeigern und Speicherverwaltung.

Ist dieser Spickzettel für Anfänger geeignet?

Ja. Er ist von den häufigsten Bausteinen (Typen, printf, Kontrollfluss) hin zu den fortgeschrittenen (Zeiger, Speicher, Structs) gegliedert, sodass du die oberen Abschnitte schon am ersten Tag nutzen und in den Rest hineinwachsen kannst.