Add C++ example: module1_memory_cpp.cpp

src/cpp_examples/module1_memory_cpp.cpp

@@ -0,0 +1,147 @@
+// ============================================
+// C++ Vergleich: Modul 1 - Memory
+// new/delete vs malloc/free + Smart Pointers
+// ============================================
+
+#include <iostream>
+#include <memory>
+#include <string>
+
+// C++: new/delete (automatisch Typ-sicher)
+void demo_new_delete() {
+    std::cout << "=== C++: new/delete ===\n\n";
+    
+    // Einzelnes Objekt
+    int* ptr = new int(42);
+    std::cout << "Value: " << *ptr << "\n";
+    delete ptr;  // Kein free(), sondern delete
+    
+    // Array
+    int* arr = new int[5]{1, 2, 3, 4, 5};
+    std::cout << "Array[2]: " << arr[2] << "\n";
+    delete[] arr;  // delete[] für Arrays!
+}
+
+// C++: Smart Pointers (automatische Speicherverwaltung)
+void demo_smart_pointers() {
+    std::cout << "\n=== C++: Smart Pointers ===\n\n";
+    
+    // unique_ptr: Einzigartiger Besitzer
+    {
+        std::unique_ptr<int> uptr = std::make_unique<int>(42);
+        std::cout << "unique_ptr: " << *uptr << "\n";
+        // Automatisch freigegeben am Ende des Blocks!
+    }
+    std::cout << "unique_ptr wurde automatisch freigegeben\n";
+    
+    // shared_ptr: Geteilter Besitzer
+    {
+        std::shared_ptr<std::string> sptr = std::make_shared<std::string>("Hello");
+        {
+            std::shared_ptr<std::string> sptr2 = sptr;  // Kopie, Referenzzähler +1
+            std::cout << "Referenzen: " << sptr.use_count() << "\n";  // 2
+        }  // sptr2 zerstört, Referenzzähler -1
+        std::cout << "Referenzen: " << sptr.use_count() << "\n";  // 1
+    }  // sptr zerstört, Speicher freigegeben
+    
+    // weak_ptr: Beobachtet ohne Besitz (verhindert Zyklen)
+    std::cout << "weak_ptr: Verhindert Referenzzyklen\n";
+}
+
+// C++: RAII (Resource Acquisition Is Initialization)
+class FileHandler {
+private:
+    std::string filename;
+    bool isOpen;
+    
+public:
+    FileHandler(const std::string& fname) 
+        : filename(fname), isOpen(true) {
+        std::cout << "Datei \"" << filename << "\" geöffnet\n";
+    }
+    
+    ~FileHandler() {
+        if (isOpen) {
+            std::cout << "Datei \"" << filename << "\" automatisch geschlossen\n";
+        }
+    }
+    
+    // Verhindert Kopieren (wie FILE* in C)
+    FileHandler(const FileHandler&) = delete;
+    FileHandler& operator=(const FileHandler&) = delete;
+    
+    // Erlaubt Moving
+    FileHandler(FileHandler&& other) noexcept
+        : filename(std::move(other.filename)), isOpen(other.isOpen) {
+        other.isOpen = false;
+    }
+};
+
+void demo_raii() {
+    std::cout << "\n=== C++: RAII ===\n\n";
+    
+    {
+        FileHandler file("test.txt");
+        // Datei wird automatisch geschlossen am Ende des Blocks
+    }
+    std::cout << "Block verlassen, Datei wurde automatisch geschlossen\n";
+}
+
+// C++: Container (kein malloc/free nötig!)
+#include <vector>
+#include <string>
+
+void demo_containers() {
+    std::cout << "\n=== C++: Container (kein malloc!) ===\n\n";
+    
+    // vector: Dynamisches Array
+    std::vector<int> vec = {1, 2, 3, 4, 5};
+    vec.push_back(6);  // Automatisch wachsen
+    
+    std::cout << "vector: ";
+    for (int x : vec) {
+        std::cout << x << " ";
+    }
+    std::cout << "\nGröße: " << vec.size() << "\n";
+    // Automatisch freigegeben am Ende!
+    
+    // string: Dynamischer String
+    std::string str = "Hello";
+    str += " World";  // Keine Buffer-Overflow-Gefahr
+    std::cout << "string: " << str << "\n";
+    std::cout << "Länge: " << str.length() << "\n";
+    
+    // 2D Array (vector of vectors)
+    std::vector<std::vector<int>> matrix(3, std::vector<int>(3, 0));
+    matrix[1][1] = 42;
+    std::cout << "Matrix[1][1]: " << matrix[1][1] << "\n";
+    // Kein manuelles free_matrix nötig!
+}
+
+// ============================================
+// Hauptprogramm
+// ============================================
+int main() {
+    std::cout << "=== C++ vs C: Memory Management ===\n\n";
+    
+    demo_new_delete();
+    demo_smart_pointers();
+    demo_raii();
+    demo_containers();
+    
+    std::cout << "\n=== Wichtige Unterschiede C vs C++ ===\n\n";
+    std::cout << "C:\n";
+    std::cout << "  - malloc/free (manuell, fehleranfällig)\n";
+    std::cout << "  - Keine automatische Freigabe\n";
+    std::cout << "  - void* für generische Daten\n";
+    std::cout << "  - Manuelle Array-Verwaltung\n\n";
+    
+    std::cout << "C++:\n";
+    std::cout << "  - new/delete (typischer)\n";
+    std::cout << "  - Smart Pointers (automatisch!)\n";
+    std::cout << "  - Templates für generische Daten\n";
+    std::cout << "  - Container (vector, string) auto-verwaltet\n";
+    std::cout << "  - RAII: Ressourcen an Objekt-Lebenszeit gebunden\n";
+    
+    return 0;
+}