C Funktionen Cheatsheet

6 Kernkonzepte

Die wichtigsten Konzepte für Funktionen in C: Deklaration · Parameter · Rückgabewerte · Prototypen · Rekursion · Zeiger Funktionen sind das Herzstück der C-Programmierung – sie strukturieren Code, fördern Wiederverwendbarkeit und ermöglichen modulare Programmierung.

Deklaration & Definition – Funktionen erstellen

rückgabeTyp name(parameter) { ... }

// Deklaration (Prototyp) int add(int a, int b); // Definition int add(int a, int b) { return a + b; }

Funktionen in C bestehen aus einer Deklaration (Prototyp) und einer Definition (Implementierung). Der Rückgabetyp und die Parametertypen müssen angegeben werden.

Bestandteile einer Funktion

Bestandteil	Beschreibung	Beispiel
Rückgabetyp	Datentyp des Rückgabewerts (`void` = kein Wert)	`int, float, void, char*`
Funktionsname	Bezeichner der Funktion	`add, printMessage`
Parameterliste	Typ und Name der Parameter (kann leer sein)	`(int a, int b)` oder `(void)`
Funktionsrumpf	Code in `{ }` Klammern	`{ return a + b; }`

Beispiele

// Einfache Funktion mit Rückgabewert

int quadrat(int x) {

return x * x;

}

// Funktion ohne Rückgabewert (void)

void printMessage(void) {

printf("Hallo Welt!\n");

}

// Funktion mit mehreren Parametern

float durchschnitt(float a, float b, float c) {

return (a + b + c) / 3;

}

Tipp: Der Funktionsprototyp (Deklaration) sollte vor dem Aufruf der Funktion stehen – entweder am Anfang der Datei oder in einer Header-Datei (.h).

Parameter – Werte übergeben

Wert · Zeiger · Arrays

// Call by Value void change(int x) { x = 10; } // Call by Reference (mit Zeiger) void change(int* x) { *x = 10; }

Parameter werden in C standardmäßig by Value übergeben – die Funktion arbeitet mit einer Kopie. Für die Änderung von Originalwerten benötigen Sie Zeiger (Call by Reference).

Parametertypen

Typ	Beschreibung	Beispiel
By Value	Kopie des Werts wird übergeben	`void f(int x)`
By Reference (Zeiger)	Adresse wird übergeben – Änderungen wirken sich aus	`void f(int* x)`
Array als Parameter	Übergabe als Zeiger auf erstes Element	`void f(int arr[], int size)`
const Parameter	Parameter darf nicht geändert werden	`void f(const int x)`

Beispiele

// Call by Value – Original bleibt unverändert

void inc(int x) {

x++; // Ändert nur die Kopie

}

// Call by Reference – Original wird geändert

void incRef(int* x) {

(*x)++; // Ändert das Original

}

// Array als Parameter

void printArray(int arr[], int size) {

for (int i = 0; i < size; i++) {

printf("%d ", arr[i]);

}

// Aufruf:

int zahl = 5;

inc(zahl); // zahl bleibt 5

incRef(&zahl); // zahl wird zu 6

Tipp: Für große Datenstrukturen (z.B. Arrays, Structs) sollten Sie immer Zeiger verwenden, um Kopien zu vermeiden und Speicher zu sparen.

Rückgabewerte – Ergebnisse zurückgeben

return · void · Zeiger

// Rückgabe eines Werts int add(int a, int b) { return a + b; } // Rückgabe eines Zeigers int* getArray() { return arr; }

Rückgabewerte werden mit return zurückgegeben. Der Rückgabetyp muss in der Funktionsdeklaration angegeben werden. void bedeutet, dass kein Wert zurückgegeben wird.

Rückgabetypen

Typ	Beschreibung	Beispiel
void	Kein Rückgabewert	`void print() { ... }`
int, float, char, ...	Rückgabe eines einzelnen Werts	`int add(int a, int b)`
Zeiger (int, char, ...)	Rückgabe einer Adresse (Array, Struct)	`int* getData()`
struct	Rückgabe einer Struktur (per Wert)	`struct Point getPoint()`

Beispiele

// Rückgabe eines int

int max(int a, int b) {

if (a > b) return a;

else return b;

}

// Rückgabe eines Zeigers auf ein Array

int* getEvenNumbers() {

static int arr[] = {2, 4, 6, 8};

return arr;

}

// Frühzeitiges return (mehrere Ausgänge)

int absolute(int x) {

if (x < 0) return -x;

return x;

}

Tipp: Verwenden Sie static für Arrays, die von einer Funktion zurückgegeben werden, damit sie nach dem Funktionsende erhalten bleiben. Oder nutzen Sie malloc für dynamische Speicherzuweisung.

Funktionsprototypen – Vorwärtsdeklaration

Prototypen · Header-Dateien

// Prototyp (Deklaration) int multiply(int a, int b); // Definition (nach main oder in anderer Datei) int multiply(int a, int b) { return a * b; }

Funktionsprototypen (Vorwärtsdeklarationen) informieren den Compiler über den Rückgabetyp und die Parameter einer Funktion, bevor sie definiert wird. Sie werden oft in Header-Dateien (.h) ausgelagert.

Wichtige Regeln

Regel	Beschreibung
Prototyp vor Aufruf	Der Compiler muss den Prototyp kennen, bevor die Funktion aufgerufen wird
Header-Dateien (.h)	Prototypen werden in Header-Dateien ausgelagert und mit `#include` eingebunden
Mehrere Dateien	Prototypen ermöglichen die Verwendung von Funktionen aus anderen Quellcodedateien
Parameter-Namen	In Prototypen sind Parameternamen optional, der Typ ist jedoch Pflicht

Beispiele

// Prototypen am Dateianfang

#include <stdio.h>

// Prototypen deklarieren

int add(int a, int b);

void printResult(int result);

// main-Funktion

int main() {

int sum = add(5, 3);

printResult(sum);

return 0;

}

// Definitionen (nach main)

int add(int a, int b) {

return a + b;

}

void printResult(int result) {

printf("Ergebnis: %d\n", result);

}

Tipp: Lagern Sie Prototypen in Header-Dateien (.h) aus und binden Sie sie mit #include ein. So können Sie Funktionen in mehreren Dateien wiederverwenden.

Rekursion – Funktion ruft sich selbst auf

Basisfall · Rekursiver Aufruf

// Fakultät rekursiv int fakultaet(int n) { // Basisfall if (n <= 1) return 1; // Rekursiver Aufruf return n * fakultaet(n - 1); }

Rekursion bedeutet, dass eine Funktion sich selbst aufruft. Jede rekursive Funktion benötigt einen Basisfall (Abbruchbedingung) und einen rekursiven Aufruf, der sich dem Basisfall annähert.

Wichtige Aspekte

Aspekt	Beschreibung
Basisfall	Abbruchbedingung – beendet die Rekursion
Rekursiver Schritt	Funktion ruft sich selbst mit veränderten Parametern auf
Stack	Jeder Aufruf belegt Speicher auf dem Call-Stack
Terminierung	Die Rekursion muss irgendwann terminieren (Basisfall erreichen)

Beispiele

// Fakultät (n!)

int fakultaet(int n) {

if (n <= 1) return 1;

return n * fakultaet(n - 1);

}

// Fibonacci-Zahlen

int fib(int n) {

if (n <= 1) return n;

return fib(n - 1) + fib(n - 2);

}

// Potenz (x^n) rekursiv

int power(int x, int n) {

if (n == 0) return 1;

if (n == 1) return x;

return x * power(x, n - 1);

}

⚠️ Achtung: Rekursion kann zu Stack Overflow führen, wenn die Rekursionstiefe zu groß wird. Für große Werte ist die iterative Lösung oft effizienter und sicherer.

Fortgeschrittene Konzepte – Zeiger, inline, variadisch

Funktionszeiger · inline · variadisch

// Funktionszeiger int (*ptr)(int, int) = &add; // inline-Funktion (C99) inline int square(int x) { return x * x; }

Fortgeschrittene Konzepte erweitern die Funktionalität von Funktionen – von der Übergabe von Funktionen als Parameter über Performance-Optimierung bis zu variadischen Funktionen.

Fortgeschrittene Techniken

Technik	Beschreibung	Beispiel
Funktionszeiger	Zeiger auf eine Funktion – für Callbacks und dynamische Auswahl	`int (*f)(int, int)`
inline	Compiler-Vorschlag zur Code-Ersetzung (Performance)	`inline int add(int a, int b)`
Variadisch	Variable Anzahl von Parametern (z.B. printf)	`int sum(int count, ...)`
static inline	Inline-Funktion mit interner Bindung	`static inline int max(int a, int b)`

Beispiele

// Funktionszeiger für Callback

void process(int x, int (*f)(int)) {

printf("%d\n", f(x));

}

// Aufruf mit verschiedenen Funktionen

process(5, quadrat); // 25

process(5, verdoppeln); // 10

// inline-Funktion (C99)

inline int verdoppeln(int x) { return x * 2; }

// Variadische Funktion (summiert beliebig viele ints)

#include <stdarg.h>

int sum(int count, ...) {

va_list args;

va_start(args, count);

int total = 0;

for (int i = 0; i < count; i++) {

total += va_arg(args, int);

}

va_end(args);

return total;

}

// Aufruf: sum(3, 1, 2, 3) → 6

Tipp: Funktionszeiger werden häufig für Callback-Funktionen verwendet (z.B. in qsort) und ermöglichen dynamische Entscheidungen zur Laufzeit.

C Funktionen im Überblick

Rückgabetyp int, float, void, char*
Typ des Rückgabewerts

Parameter Wert oder Zeiger
Call by Value / Reference

Prototyp Vorwärtsdeklaration
In .h-Dateien

Rekursion Selbstaufruf
Basisfall erforderlich

inline Code-Ersetzung
Performance-Optimierung

Funktionszeiger Callback-Funktionen
Dynamische Auswahl

Quick Summary

int f(int)

Deklaration

int* p

Zeiger-Übergabe

return x

Rückgabe

prototype

Header-Dateien

Rekursion

Selbstaufruf

inline

Performance

int add(int a, int b) { return a + b; } · void f(int* x) { *x = 10; }