Add module4_functions.c

src/c_examples/module4_functions.c

@@ -0,0 +1,149 @@
+// ============================================
+// Modul 4: Funktionen
+// Beispiele in C
+// ============================================
+
+#include <stdio.h>
+#include <stdlib.h>
+
+// Beispiel 4.1: Funktionskonzepte
+
+// 1. Einfache Funktion (Call-by-Value)
+int add(int a, int b) {
+    return a + b;
+}
+
+// 2. Funktion ohne Rückgabe (void)
+void greet(const char* name) {
+    printf("Hallo, %s!\n", name);
+}
+
+// 3. Call-by-Reference (mit Pointern)
+void swap_wrong(int a, int b) {  // Call-by-Value!
+    int temp = a;
+    a = b;
+    b = temp;
+    // Ändert nichts am Aufrufer!
+}
+
+void swap_correct(int* a, int* b) {  // Call-by-Reference (via Pointer)
+    int temp = *a;
+    *a = *b;
+    *b = temp;
+    // ✅ Ändert Originalwerte!
+}
+
+// 4. Funktion mit Array-Parameter
+int sum_array(int arr[], int size) {
+    int sum = 0;
+    for (int i = 0; i < size; i++) {
+        sum += arr[i];
+    }
+    return sum;
+}
+
+// 5. Rekursion: Fakultät
+int factorial(int n) {
+    // Base Case
+    if (n <= 1) return 1;
+    
+    // Recursive Case
+    return n * factorial(n - 1);
+}
+
+// 6. Rekursion: Fibonacci
+int fibonacci(int n) {
+    if (n <= 1) return n;
+    return fibonacci(n - 1) + fibonacci(n - 2);
+}
+
+// 7. Tail Recursion (optimierbar)
+int factorial_tail_helper(int n, int acc) {
+    if (n <= 1) return acc;
+    return factorial_tail_helper(n - 1, n * acc);
+}
+
+int factorial_tail(int n) {
+    return factorial_tail_helper(n, 1);
+}
+
+// 8. Function Pointers
+int add_op(int a, int b) { return a + b; }
+int sub_op(int a, int b) { return a - b; }
+int mul_op(int a, int b) { return a * b; }
+
+void demo_function_pointers() {
+    printf("\n=== Function Pointers ===\n\n");
+    
+    // Array von Funktionspointern
+    int (*operations[])(int, int) = {add_op, sub_op, mul_op};
+    char* names[] = {"Add", "Sub", "Mul"};
+    
+    int a = 10, b = 3;
+    for (int i = 0; i < 3; i++) {
+        int result = operations[i](a, b);
+        printf("%s(%d, %d) = %d\n", names[i], a, b, result);
+    }
+}
+
+// 9. Static Variables (Persistenz)
+void counter_function() {
+    static int counter = 0;  // Wird nur einmal initialisiert!
+    counter++;
+    printf("Aufruf Nummer: %d\n", counter);
+}
+
+// ============================================
+// Hauptprogramm
+// ============================================
+int main() {
+    printf("=== Modul 4: Funktionen ===\n\n");
+    
+    // Einfache Funktionen
+    printf("--- Einfache Funktionen ---\n");
+    int result = add(5, 3);
+    printf("add(5, 3) = %d\n", result);
+    
+    greet("Student");
+    
+    // Call-by-Value vs Call-by-Reference
+    printf("\n--- Parameterübergabe ---\n");
+    int x = 10, y = 20;
+    printf("Vor swap: x=%d, y=%d\n", x, y);
+    
+    swap_wrong(x, y);
+    printf("Nach swap_wrong: x=%d, y=%d (keine Änderung!)\n", x, y);
+    
+    swap_correct(&x, &y);
+    printf("Nach swap_correct: x=%d, y=%d (getauscht!)\n", x, y);
+    
+    // Arrays
+    printf("\n--- Arrays als Parameter ---\n");
+    int numbers[] = {1, 2, 3, 4, 5};
+    int total = sum_array(numbers, 5);
+    printf("Summe: %d\n", total);
+    
+    // Rekursion
+    printf("\n--- Rekursion ---\n");
+    printf("5! = %d\n", factorial(5));
+    printf("fibonacci(10) = %d\n", fibonacci(10));
+    printf("factorial_tail(5) = %d\n", factorial_tail(5));
+    
+    // Function Pointers
+    demo_function_pointers();
+    
+    // Static Variables
+    printf("\n--- Static Variables ---\n");
+    for (int i = 0; i < 3; i++) {
+        counter_function();
+    }
+    
+    printf("\n=== Wichtige Konzepte ===\n");
+    printf("1. C ist immer Call-by-Value\n");
+    printf("2. Pointer ermöglichen Call-by-Reference\n");
+    printf("3. Rekursion braucht Base Case\n");
+    printf("4. Function Pointers = Flexibilität\n");
+    printf("5. static = Persistenz über Aufrufe\n");
+    
+    return 0;
+}