C Grundlagen Cheatsheet

6 Kernkonzepte

Die wichtigsten Grundlagen der C-Programmierung: Syntax · Variablen · Datentypen · Operatoren · Funktionen · Zeiger C ist eine der einflussreichsten Programmiersprachen – die Grundlage für Betriebssysteme, Embedded-Systeme und viele andere Sprachen. Diese Grundlagen sind der Einstieg in die C-Programmierung.

Syntax – Die Grundregeln

#include · ; · {} · main()

// Einzeiliger Kommentar /* Mehrzeiliger Kommentar */ #include <stdio.h> int main() { printf("Hallo Welt!"); return 0; }

C-Syntax ist die Grundlage vieler moderner Sprachen. Jede Anweisung endet mit einem Semikolon ;, Codeblöcke werden mit {} umschlossen. main() ist der Einstiegspunkt jedes C-Programms.

Wichtige Syntax-Regeln

Regel	Beschreibung
//	Einzeiliger Kommentar (C99+)
/* ... */	Mehrzeiliger Kommentar
;	Semikolon beendet jede Anweisung
{}	Geschweifte Klammern definieren Codeblöcke
#include	Header-Dateien einbinden
case-sensitiv	C unterscheidet zwischen Groß- und Kleinschreibung

Beispiele

// Einzeiliger Kommentar

Mehrzeiliger

Kommentar

#include <stdio.h> // Standard-Ein-/Ausgabe

#include <stdlib.h> // Standardbibliothek

int main() { // Einstiegspunkt

printf("Hallo Welt!\n");

return 0; // Erfolgreiches Beenden

}

Tipp: Jedes C-Programm benötigt eine main()-Funktion. Der Rückgabewert 0 signalisiert dem Betriebssystem, dass das Programm erfolgreich beendet wurde.

Variablen – Daten speichern

int · float · char · Deklaration

int alter = 30; // Ganzzahl float preis = 19.99; // Gleitkommazahl char buchstabe = 'A'; // Einzelzeichen

Variablen in C müssen vor der Verwendung deklariert werden – mit Angabe des Datentyps. C ist statisch typisiert: der Typ einer Variable kann sich nicht ändern.

Regeln für Variablennamen

Regel	Beschreibung
Buchstaben, Ziffern, _	Erlaubte Zeichen (keine Sonderzeichen)
Nicht mit Ziffer	Name darf nicht mit einer Zahl beginnen
Groß-/Kleinschreibung	C unterscheidet zwischen Groß- und Kleinschreibung
Reservierte Wörter	Nicht verwenden: int, float, if, for, while, etc.
Konventionen	snake_case oder camelCase (je nach Projekt)

Beispiele

// Deklaration und Initialisierung

int x = 5;

float y = 3.14;

char c = 'A';

// Mehrere Variablen deklarieren

int a, b, c;

a = 10;

b = a + 5;

// Konstante (unveränderbar)

const int MAX = 100;

// MAX = 200; // Fehler: const darf nicht geändert werden

Tipp: In C müssen Variablen am Anfang eines Blocks deklariert werden (vor allen Anweisungen). In C99+ ist die Deklaration auch später im Block möglich.

Datentypen – int, float, char, double

sizeof · int · float · double · char

printf("%lu", sizeof(int)); // 4 (meistens) printf("%lu", sizeof(char)); // 1

Datentypen definieren, welche Werte eine Variable annehmen kann und wie viel Speicher sie belegt. C ist eine statisch typisierte Sprache mit festen Speichergrößen.

Die wichtigsten Datentypen

Typ	Größe (typisch)	Wertebereich	Beispiel
char	1 Byte	-128 bis 127	char c = 'A';
int	4 Byte	-2.147.483.648 bis 2.147.483.647	int x = 42;
short	2 Byte	-32.768 bis 32.767	short s = 1000;
long	8 Byte (64-bit)	-9.2e18 bis 9.2e18	long l = 123456789L;
float	4 Byte	~1.2e-38 bis ~3.4e38	float f = 3.14f;
double	8 Byte	~2.2e-308 bis ~1.8e308	double d = 3.14159;
unsigned	wie int	0 bis 4.294.967.295	unsigned int u = 100;

Beispiele

// Größen prüfen mit sizeof

printf("int: %lu Byte\n", sizeof(int));

printf("float: %lu Byte\n", sizeof(float));

printf("double: %lu Byte\n", sizeof(double));

printf("char: %lu Byte\n", sizeof(char));

// Typumwandlung (Casting)

int a = 10;

float b = (float)a / 3; // 3.333...

Tipp: Die Größen von Datentypen können je nach Plattform variieren. Verwenden Sie sizeof(), um die tatsächliche Größe zur Laufzeit zu ermitteln.

Operatoren – Rechnen & Vergleichen

+ - * / % · == != < > · && || !

summe = 10 + 5; // 15 rest = 10 % 3; // 1 gleich = (5 == 5); // 1 (true)

Operatoren führen Berechnungen und Vergleiche durch. C bietet arithmetische, Vergleichs-, logische und bitweise Operatoren.

Die wichtigsten Operatoren

Kategorie	Operatoren	Beispiel
Arithmetik	+, -, *, /, %	10 % 3 = 1
Vergleich	==, !=, <, >, <=, >=	5 > 3 = 1 (true)
Logik	&&, \|\|, !	(5 > 3) && (2 < 4) = 1
Zuweisung	=, +=, -=, *=, /=, %=	x += 5 → x = x + 5
Inkrement/Dekrement	++, --	i++ → i = i + 1
Bitweise	&, \|, ^, ~, <<, >>	5 & 3 = 1

Beispiele

// Arithmetische Operatoren

int a = 10, b = 3;

printf("%d\n", a / b); // 3 (Ganzzahldivision)

printf("%d\n", a % b); // 1

// Vergleichsoperatoren

printf("%d\n", a == b); // 0 (false)

printf("%d\n", a > b); // 1 (true)

// Inkrement-Operator

int i = 0;

i++; // i = 1

++i; // i = 2

Tipp: Bei der Division zweier int-Werte wird das Ergebnis abgeschnitten (Ganzzahldivision). Für Gleitkommadivision muss mindestens ein Operand float oder double sein.

Funktionen – Code wiederverwenden

return · Parameter · void

int add(int a, int b) { return a + b; } add(5, 3); // 8

Funktionen sind wiederverwendbare Codeblöcke. Sie können Parameter entgegennehmen und Werte mit return zurückgeben. void bedeutet, dass keine Rückgabe erfolgt.

Funktions-Deklarationen

Art	Beschreibung	Beispiel
Mit Rückgabewert	Gibt einen Wert zurück	int add(int a, int b) { return a + b; }
Ohne Rückgabewert	Führt Aktionen aus	void print(int x) { printf("%d", x); }
Mit Parametern	Nimmt Werte entgegen	int max(int a, int b) { ... }
Ohne Parameter	Nimmt keine Werte entgegen	int random() { ... }
Prototyp	Deklaration vor main()	int add(int a, int b);

Beispiele

// Funktionsprototyp (Deklaration)

int quadrat(int x);

// Funktion mit Rückgabewert

int quadrat(int x) {

return x * x;

}

// Funktion ohne Rückgabewert (void)

void gruss(char name[]) {

printf("Hallo %s!\n", name);

}

// Aufruf in main()

int ergebnis = quadrat(5); // 25

gruss("Anna"); // "Hallo Anna!"

Tipp: Deklarieren Sie Funktionen vor main() (Prototyp), damit der Compiler sie kennt. Ohne Prototyp benötigen Sie die vollständige Definition vor dem Aufruf.

Zeiger – Speicheradressen verwalten

* · & · malloc · free

int x = 10; int *ptr = &x; // ptr zeigt auf x *ptr = 20; // x ist jetzt 20

Zeiger (Pointer) sind Variablen, die Speicheradressen speichern. Sie sind eines der mächtigsten und gleichzeitig anspruchsvollsten Konzepte in C. & holt die Adresse, * dereferenziert einen Zeiger.

Wichtige Zeiger-Operationen

Syntax	Beschreibung	Beispiel
int *ptr;	Zeiger auf int deklarieren	Zeiger auf Ganzzahl
&variable	Adresse von variable	&x → Adresse von x
*ptr	Dereferenzierung (Wert an der Adresse)	*ptr = 42;
NULL	Nullzeiger (zeigt auf nichts)	int *ptr = NULL;
malloc(size)	Dynamischer Speicher (Heap)	int arr = malloc(10 sizeof(int));
free(ptr)	Speicher freigeben	free(arr);

Beispiele

// Einfacher Zeiger

int zahl = 42;

int *ptr = &zahl;

printf("Wert: %d\n", *ptr); // 42

printf("Adresse: %p\n", (void*)ptr);

// Zeiger auf Array

int arr[] = {1, 2, 3};

int *p = arr; // arr == &arr[0]

printf("%d\n", p[0]); // 1

printf("%d\n", *(p + 1)); // 2

// Dynamischer Speicher (Heap)

int *dyn = (int*)malloc(5 * sizeof(int));

if (dyn != NULL) {

dyn[0] = 100;

printf("%d\n", dyn[0]); // 100

free(dyn); // Speicher freigeben

}

⚠️ Warnung: Vergessen Sie nicht, dynamisch allokierten Speicher mit free() freizugeben – sonst entsteht ein Speicherleck. Setzen Sie Zeiger nach free() auf NULL, um doppelte Freigaben zu vermeiden.

C Grundlagen im Überblick

#include Header einbinden
stdio.h, stdlib.h

main() Einstiegspunkt
return 0

printf() Ausgabe
%d, %f, %s, %p

scanf() Eingabe
&variable

* & Zeiger
Dereferenzierung, Adresse

malloc() Dynamischer Speicher
free() nicht vergessen

Quick Summary

;

Anweisungsende

int x = 5;

Variable

sizeof

Typgröße

+ - * /

Operatoren

return

Funktion

* &

Zeiger

#include <stdio.h> · int main() { printf("Hallo"); return 0; } · int *ptr = &x;