Funktionen
Funktionen in C ermöglichen die Strukturierung des Programms, Wiederverwendbarkeit von Code und bessere Lesbarkeit.
Diese Lektion behandelt Deklaration, Definition, Parameter, Rückgabewerte und Gültigkeitsbereich.
1. Definition einer Funktion
Eine Funktion ist ein benannter Codeblock, der optional Parameter empfängt und einen Wert zurückgeben kann.
int add(int a, int b) {
return a + b;
}
int vor dem Funktionsnamen bezeichnet den Rückgabewert
void bedeutet, dass keine Rückgabe erfolgt
2. Funktionsdeklaration vs. Definition
Die Deklaration informiert den Compiler über Name, Parameter und Rückgabewert, die Definition enthält den eigentlichen Code.
// Deklaration
int multiply(int x, int y);
// Definition
int multiply(int x, int y) {
return x * y;
}
3. Funktionsaufruf
Funktionen werden durch ihren Namen mit passenden Argumenten aufgerufen.
int result = multiply(3, 4); // result = 12
printf("%d\n", result);
4. Parameterarten
In C gibt es **Call by Value**. Parameterwerte werden kopiert. Änderungen wirken nur lokal.
void increment(int x) {
x++;
}
int a = 5;
increment(a); // a bleibt 5
Änderungen innerhalb der Funktion wirken **nicht** auf den ursprünglichen Wert außerhalb.
5. Rückgabewerte
Funktionen können einen Wert zurückgeben. Rückgabe erfolgt mit return.
double square(double x) {
return x * x;
}
double result = square(2.5); // 6.25
6. Gültigkeitsbereich (Scope)
Variablen in Funktionen haben **lokalen Scope** und existieren nur während der Funktionsausführung.
void foo() {
int x = 10; // lokal
printf("%d\n", x);
}
// x hier nicht definiert
7. Mehrere Funktionen und Modularität
Durch Aufteilung in Funktionen wird Code modular und wiederverwendbar.
int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }
int main(void) {
int sum = add(3,4);
int prod = multiply(3,4);
printf("sum=%d prod=%d\n", sum, prod);
return 0;
}
8. Zusammenfassung
- Funktionen sind benannte Codeblöcke mit Parametern und Rückgabewerten
- Deklaration vs. Definition: Compiler vs. Code
- Aufruf mit Argumenten
- Call by Value: Parameter werden kopiert
- Lokaler Scope: Variablen existieren nur in der Funktion
- Modularität: Wiederverwendbarkeit und bessere Struktur