Natuurlijk! Hier is een overzicht van moderne C++20-kenmerken en hoe je ze kunt gebruiken, inclusief voorbeelden en uitleg. 1. Concepts Concepts maken het mogelijk om template-parameters te constrainen op bepaalde eigenschappen. Dit verhoogt de codeleesbaarheid en foutmeldingen. Voorbeeld: ```cpp #include <concepts> #include <iostream> template<std::integral T> void print_integral(T val) { std::cout << "Integral value: " << val << '\n'; } ``` Hier wordt gegarandeerd dat `T` een integraal type is. 2. Ranges De ranges-bibliotheek biedt een krachtigere en meer declaratieve manier om met collecties te werken, vergelijkbaar met Python's iterables. Voorbeeld: ```cpp #include <ranges> #include <vector> #include <algorithm> #include <iostream> int main() { std::vector<int> vec = {1, 2, 3, 4, 5}; auto even_numbers = vec | std::ranges::views::filter([](int n){ return n % 2 == 0; }); for (int n : even_numbers) { std::cout << n << ' '; } } ``` 3. Coroutines Coroutines maken asynchrone en generator-achtige functies mogelijk zonder expliciete state-machine code te schrijven. Voorbeeld (generator): ```cpp #include <coroutine> #include <iostream> template<typename T> struct generator { struct promise_type { T current_value; auto get_return_object() { return generator{this}; } auto initial_suspend() { return std::suspend_always{}; } auto final_suspend() noexcept { return std::suspend_always{}; } auto yield_value(T value) { current_value = value; return std::suspend_always{}; } void return_void() {} void unhandled_exception() { std::terminate(); } }; struct iterator { generator* gen; bool done = false; iterator& operator++() { gen->coro.resume(); done = gen->coro.done(); return *this; } T operator*() const { return gen->promise().current_value; } bool operator==(std::default_sentinel_t) const { return done; } }; generator(promise_type* p) : coro(std::coroutine_handle<promise_type>::from_promise(*p)) {} ~generator() { if(coro) coro.destroy(); } auto begin() { coro.resume(); return iterator{this, false}; } auto end() { return std::default_sentinel; } std::coroutine_handle<promise_type> coro; }; generator<int> get_numbers() { for(int i = 0; i < 5; ++i) { co_yield i; } } int main() { for(auto n : get_numbers()) { std::cout << n << ' '; } } ``` 4. Modules Modules vervangen de traditionele header-bestanden en verbeteren de build-tijden en encapsulatie. Voorbeeld: Maak een module (voorbeeldbestand `mijnmodule.cppm`): ```cpp export module mijnmodule; export int add(int a, int b) { return a + b; } ``` Gebruik de module in een ander bestand: ```cpp import mijnmodule; #include <iostream> int main() { std::cout << add(3, 4) << '\n'; } ``` 5. Jouw voorbeeld met templates: Je huidige code: ```cpp template<typename T> void func(T val) { /* ... */ } void func(T val) { /* ... */ } ``` Hier zit een conflict doordat je beide functies hebt, waarbij de tweede niet kan bestaan zonder template. In moderne C++20 is het mogelijk om via concepts meer controle te krijgen, bijvoorbeeld: ```cpp #include <concepts> template<typename T> concept MyConcept = requires(T a) { { a.some_method() } -> std::same_as<void>; }; template<MyConcept T> void func(T val) { // implementation voor types die aan MyConcept voldoen } ``` Samenvatting: - **Concepts** voor constraining van templates. - **Ranges** voor declaratieve data-processing. - **Coroutines** voor asynchrone en generator functies. - **Modules** voor betere code-organisatie en snellere builds. Wil je een specifiek voorbeeld of uitleg over een van deze features?

Je hebt een duplicaat functiedefinitie in je voorbeeld. Laten we eerst dat oplossen en dan moderne C++20 features toevoegen. ## Oplossing dubbele definitie ```cpp // Fout: twee keer dezelfde functie template<typename T> void func(T val) { /* ... */ } void func(T val) { /* ... */ } // ❌ Duplicaat // Correct: template<typename T> void func(T val) { /* ... */ } ``` ## Moderne C++20 Features ### 1. Concepts (Type Constraints) ```cpp #include <concepts> // Concept voor numerieke types template<typename T> concept Numeriek = std::integral<T> || std::floating_point<T>; // Gebruik concept als constraint template<Numeriek T> void verwerkGetal(T waarde) { // Alleen numerieke types toegestaan auto resultaat = waarde * 2; } // Alternatieve syntax template<typename T> requires Numeriek<T> void andereFunctie(T val) { // ... } // Voorbeeld gebruik verwerkGetal(42); // ✅ OK verwerkGetal(3.14); // ✅ OK // verwerkGetal("text"); // ❌ Compilefout ``` ### 2. Ranges (Modern iteratie) ```cpp #include <ranges> #include <vector> #include <iostream> #include <algorithm> void demonstreerRanges() { std::vector<int> getallen{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // Filter even getallen en transformeer auto resultaat = getallen | std::views::filter([](int n) { return n % 2 == 0; }) | std::views::transform([](int n) { return n * 2; }); for (auto n : resultaat) { std::cout << n << " "; // Output: 4 8 12 16 20 } } ``` ### 3. Coroutines (Asynchrone programming) ```cpp #include <coroutine> #include <iostream> struct Generator { struct promise_type { int current_value; Generator get_return_object() { return Generator{std::coroutine_handle<promise_type>::from_promise(*this)}; } std::suspend_always initial_suspend() { return {}; } std::suspend_always final_suspend() noexcept { return {}; } void unhandled_exception() {} std::suspend_always yield_value(int value) { current_value = value; return {}; } void return_void() {} }; std::coroutine_handle<promise_type> coro; explicit Generator(std::coroutine_handle<promise_type> h) : coro(h) {} ~Generator() { if (coro) coro.destroy(); } int next() { coro.resume(); return coro.promise().current_value; } }; Generator genereerGetallen() { for (int i = 0; i < 5; ++i) { co_yield i * 2; } } // Gebruik: // auto gen = genereerGetallen(); // std::cout << gen.next(); // 0 // std::cout << gen.next(); // 2 // etc. ``` ### 4. Modules (Vervanging voor headers) ```cpp // math.ixx (module file) export module math; export namespace math { template<Numeriek T> T kwadraat(T x) { return x * x; } double wortel(double x); } // main.cpp import math; import <iostream>; int main() { std::cout << math::kwadraat(5); // 25 } ``` ### 5. Gecombineerd voorbeeld met Concepts en Ranges ```cpp #include <ranges> #include <vector> #include <concepts> #include <iostream> template<typename T> concept Sorteerbaar = requires(T a, T b) { { a < b } -> std::convertible_to<bool>; }; template<Sorteerbaar T> void sorteerEnToon(std::vector<T>& items) { std::ranges::sort(items); for (const auto& item : items | std::views::take(5)) { std::cout << item << " "; } } // Gebruik met structured bindings auto [min, max] = std::ranges::minmax(container); ``` ## Belangrijke best practices: 1. **Use `auto` waar mogelijk** 2. **Prefer ranges over traditionele loops** 3. **Use concepts voor betere compile-time checks** 4. **Consider modules voor grote projecten** 5. **Use coroutines voor asynchrone operaties** Wil je dat ik dieper inga op een specifieke feature of een concreet gebruiksvoorbeeld bekijk?