Lambda-functies in C++ bieden een krachtige manier om korte, anonieme functies te schrijven die je code leesbaarder en efficiënter maken. Ze zijn vooral handig bij het gebruik van standaardbibliotheekfuncties en voor het definiëren van inline functies. Hier volgt een uitleg met voorbeelden: 1. Basisgebruik en voorbeeld: Je voorbeeld: ```cpp auto add = [](int a, int b) { return a + b; }; ``` Dit definieert een lambda die twee integers optelt en opslaat in een variabele `add`. Je kunt deze lambda nu gebruiken: ```cpp int resultaat = add(3, 4); // resultaat is 7 ``` 2. Variabelen capteren: Je kunt variabelen uit de omgeving vastleggen (capture) door ze tussen `[]` te plaatsen. Voorbeeld: ```cpp int factor = 10; auto multiply = [factor](int a) { return a * factor; }; int result = multiply(5); // resultaat is 50 ``` Hier wordt `factor` vastgelegd en gebruikt binnen de lambda. 3. Specificeren van returntype: Standaard kan C++ het returntype afleiden. Soms wil je dit expliciet aangeven, bijvoorbeeld bij complexe expressies. Voorbeeld: ```cpp auto divide = [](int a, int b) -> double { return static_cast<double>(a) / b; }; ``` Hier wordt `-> double` gebruikt om het returntype te specificeren. 4. Lambdas gebruiken in standaardbibliotheekfuncties: Lambdas passen perfect bij functies zoals `std::sort`, `std::for_each`, etc. Voorbeeld: ```cpp #include <algorithm> #include <vector> #include <iostream> int main() { std::vector<int> vec = {5, 2, 8, 1, 4}; // Sorteren met lambda std::sort(vec.begin(), vec.end(), [](int a, int b) { return a < b; // sortering in oplopende volgorde }); // Voorbeeld van for_each met lambda std::for_each(vec.begin(), vec.end(), [](int n) { std::cout << n << " "; }); std::cout << std::endl; return 0; } ``` Samengevat: Lambda's in C++ maken je code korter en flexibeler door inline functies te bieden die je snel kunt gebruiken en aanpassen, vooral in combinatie met standaardbibliotheekfuncties.

Zeker! Hier is een uitgebreide uitleg over lambda-functies in C++: ## Basis Lambda Syntaxis ```cpp auto add = [](int a, int b) { return a + b; }; int resultaat = add(3, 5); // resultaat = 8 ``` ## Variabele Capture (Vangen van variabelen) ### 1. Capture by value (`[=]`) ```cpp int x = 10; auto vermenigvuldig = [=](int y) { return x * y; }; int resultaat = vermenigvuldig(5); // resultaat = 50 ``` ### 2. Capture by reference (`[&]`) ```cpp int teller = 0; auto increment = [&](int waarde) { teller += waarde; }; increment(5); // teller wordt nu 5 ``` ### 3. Specifieke variabelen vangen ```cpp int a = 5, b = 3, c = 2; auto bereken = [a, &b](int x) { b += x; // b by reference return a * x; // a by value }; ``` ## Return Type Specificatie ### Impliciet return type ```cpp auto dubbel = [](int x) { return x * 2; }; // return type wordt afgeleid ``` ### Expliciet return type ```cpp auto percentage = [](double deel, double geheel) -> double { if (geheel == 0) return 0.0; return (deel / geheel) * 100.0; }; ``` ## Toepassing in Standaardbibliotheek ### 1. Met `std::sort` ```cpp #include <vector> #include <algorithm> std::vector<int> getallen = {5, 2, 8, 1, 9}; std::sort(getallen.begin(), getallen.end(), [](int a, int b) { return a > b; // Sorteer aflopend }); ``` ### 2. Met `std::for_each` ```cpp #include <vector> #include <algorithm> std::vector<int> getallen = {1, 2, 3, 4, 5}; int som = 0; std::for_each(getallen.begin(), getallen.end(), [&som](int x) { som += x; }); ``` ### 3. Met `std::find_if` ```cpp #include <vector> #include <algorithm> std::vector<int> getallen = {1, 3, 5, 7, 9}; int drempel = 6; auto it = std::find_if(getallen.begin(), getallen.end(), [drempel](int x) { return x > drempel; // Zoek eerste getal groter dan 6 }); ``` ## Geavanceerde Voorbeelden ### Lambda met meerdere statements ```cpp auto complexeBerekening = [](int x) -> std::pair<int, int> { int kwadraat = x * x; int kubus = x * x * x; return {kwadraat, kubus}; }; auto resultaat = complexeBerekening(4); // {16, 64} ``` ### Lambda als functieparameter ```cpp #include <functional> void verwerkGetallen(const std::vector<int>& getallen, std::function<void(int)> verwerker) { for (int getal : getallen) { verwerker(getal); } } // Gebruik: std::vector<int> getallen = {1, 2, 3, 4}; verwerkGetallen(getallen, [](int x) { std::cout << "Getal: " << x << std::endl; }); ``` ## Voordelen - **Kortere code**: Minder boilerplate dan named functions - **Lokale scope**: Lambdas kunnen lokale variabelen gebruiken - **Flexibiliteit**: Makkelijk aan te passen voor specifieke use cases - **Performance**: Compiler kan lambdas vaak optimaliseren Lambdas zijn bijzonder nuttig voor korte, eenmalige functies en bij het werken met de STL-algoritmen!