Add C++ example: module5_datastructures_cpp.cpp

src/cpp_examples/module5_datastructures_cpp.cpp

@@ -0,0 +1,219 @@
+// ============================================
+// C++ Vergleich: Modul 5 - Datenstrukturen
+// STL (Standard Template Library)
+// ============================================
+
+#include <iostream>
+#include <vector>
+#include <list>
+#include <stack>
+#include <queue>
+#include <map>
+#include <algorithm>
+#include <string>
+
+// C++: vector (dynamisches Array)
+void demo_vector() {
+    std::cout << "=== C++: vector (wie C-Vector, aber besser) ===\n\n";
+    
+    // Erstellen
+    std::vector<int> vec = {10, 20, 30};
+    
+    // Hinzufügen
+    vec.push_back(40);  // Automatisch wachsen!
+    
+    // Zugriff
+    std::cout << "vec[0]: " << vec[0] << "\n";
+    std::cout << "vec.at(1): " << vec.at(1) << "\n";  // Mit Bounds-Check
+    
+    // Größe
+    std::cout << "Size: " << vec.size() << "\n";
+    std::cout << "Capacity: " << vec.capacity() << "\n";
+    
+    // Iterieren
+    std::cout << "Alle Elemente: ";
+    for (int x : vec) {
+        std::cout << x << " ";
+    }
+    std::cout << "\n\n";
+    
+    // Kein manuelles free nötig!
+}
+
+// C++: list (doppelt verkettete Liste)
+void demo_list() {
+    std::cout << "=== C++: list (Linked List) ===\n\n";
+    
+    std::list<int> lst = {30, 20, 10};
+    
+    // Einfügen
+    lst.push_front(5);  // Am Anfang
+    lst.push_back(40);  // Am Ende
+    
+    // Entfernen
+    lst.remove(20);  // Alle 20 entfernen
+    
+    // Iterieren
+    std::cout << "Alle Elemente: ";
+    for (int x : lst) {
+        std::cout << x << " ";
+    }
+    std::cout << "\n\n";
+}
+
+// C++: stack (LIFO)
+void demo_stack() {
+    std::cout << "=== C++: stack (LIFO) ===\n\n";
+    
+    std::stack<int> st;
+    
+    // Push
+    st.push(10);
+    st.push(20);
+    st.push(30);
+    
+    std::cout << "Top: " << st.top() << "\n";
+    
+    // Pop
+    st.pop();
+    std::cout << "Nach pop, top: " << st.top() << "\n";
+    
+    std::cout << "Size: " << st.size() << "\n\n";
+}
+
+// C++: queue (FIFO)
+void demo_queue() {
+    std::cout << "=== C++: queue (FIFO) ===\n\n";
+    
+    std::queue<std::string> q;
+    
+    // Enqueue
+    q.push("Erster");
+    q.push("Zweiter");
+    q.push("Dritter");
+    
+    std::cout << "Front: " << q.front() << "\n";
+    std::cout << "Back: " << q.back() << "\n";
+    
+    // Dequeue
+    q.pop();
+    std::cout << "Nach dequeue, front: " << q.front() << "\n\n";
+}
+
+// C++: map (Hash Map / Dictionary)
+void demo_map() {
+    std::cout << "=== C++: map (Hash Map) ===\n\n";
+    
+    std::map<std::string, int> scores;
+    
+    // Einfügen
+    scores["Alice"] = 95;
+    scores["Bob"] = 87;
+    scores["Charlie"] = 92;
+    
+    // Zugriff
+    std::cout << "Alice: " << scores["Alice"] << "\n";
+    
+    // Prüfen ob vorhanden
+    if (scores.find("David") == scores.end()) {
+        std::cout << "David nicht gefunden\n";
+    }
+    
+    // Iterieren
+    std::cout << "\nAlle Scores:\n";
+    for (const auto& pair : scores) {
+        std::cout << pair.first << ": " << pair.second << "\n";
+    }
+    
+    std::cout << "\n";
+}
+
+// C++: Algorithmen
+void demo_algorithms() {
+    std::cout << "=== C++: Algorithmen (STL) ===\n\n";
+    
+    std::vector<int> vec = {3, 1, 4, 1, 5, 9, 2, 6};
+    
+    // Sortieren
+    std::sort(vec.begin(), vec.end());
+    std::cout << "Sortiert: ";
+    for (int x : vec) std::cout << x << " ";
+    std::cout << "\n";
+    
+    // Binary Search
+    bool found = std::binary_search(vec.begin(), vec.end(), 5);
+    std::cout << "5 gefunden: " << (found ? "ja" : "nein") << "\n";
+    
+    // Find
+    auto it = std::find(vec.begin(), vec.end(), 4);
+    if (it != vec.end()) {
+        std::cout << "4 gefunden an Position: " << std::distance(vec.begin(), it) << "\n";
+    }
+    
+    // Min/Max
+    auto [minIt, maxIt] = std::minmax_element(vec.begin(), vec.end());
+    std::cout << "Min: " << *minIt << ", Max: " << *maxIt << "\n";
+    
+    // Count
+    int count = std::count(vec.begin(), vec.end(), 1);
+    std::cout << "Anzahl 1er: " << count << "\n";
+    
+    // Transform (map)
+    std::vector<int> doubled;
+    std::transform(vec.begin(), vec.end(), std::back_inserter(doubled),
+                   [](int x) { return x * 2; });
+    
+    std::cout << "Verdoppelt: ";
+    for (int x : doubled) std::cout << x << " ";
+    std::cout << "\n\n";
+}
+
+// C++: pair und tuple
+void demo_pair_tuple() {
+    std::cout << "=== C++: pair und tuple ===\n\n";
+    
+    // pair: Zwei Werte
+    std::pair<std::string, int> student = {"Alice", 95};
+    std::cout << "Student: " << student.first << " = " << student.second << "\n";
+    
+    // Auto + structured binding (C++17)
+    auto [name, score] = student;
+    std::cout << "Destructured: " << name << " = " << score << "\n";
+    
+    // tuple: Mehrere Werte
+    std::tuple<std::string, int, double> record = {"Project", 42, 3.14};
+    std::cout << "Tuple: " << std::get<0>(record) << ", " 
+              << std::get<1>(record) << ", " 
+              << std::get<2>(record) << "\n\n";
+}
+
+// ============================================
+// Hauptprogramm
+// ============================================
+int main() {
+    std::cout << "=== C++ STL: Datenstrukturen ===\n\n";
+    
+    demo_vector();
+    demo_list();
+    demo_stack();
+    demo_queue();
+    demo_map();
+    demo_algorithms();
+    demo_pair_tuple();
+    
+    std::cout << "=== Vergleich: C vs C++ ===\n\n";
+    std::cout << "C:\n";
+    std::cout << "  - Manuelle Implementierung (LinkedList, Stack, Queue)\n";
+    std::cout << "  - malloc/free für jedes Element\n";
+    std::cout << "  - Keine built-in Algorithmen\n";
+    std::cout << "  - Keine Generics (void* casts)\n\n";
+    
+    std::cout << "C++ STL:\n";
+    std::cout << "  - Fertige, optimierte Container\n";
+    std::cout << "  - Automatische Speicherverwaltung\n";
+    std::cout << "  - 100+ Algorithmen (sort, find, binary_search...)\n";
+    std::cout << "  - Templates (typsichere Generics)\n";
+    std::cout << "  - Iteratoren für einheitliche Schnittstelle\n";
+    
+    return 0;
+}