C++ for C Developers | Lesson 14: Introduction to Lambdas & Basic STL Algorithms

#include <vector>
#include <algorithm> // For std::find_if

// We need a function to check if a number is even for std::find_if
bool isEven(int n) {
    return n % 2 == 0;
}

int main_old_style() {
    std::vector<int> nums = {1, 3, 5, 4, 7, 8};
    // Find the first even number using a separate function
    auto it = std::find_if(nums.begin(), nums.end(), isEven);
    // ...
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm> // Essential for algorithms!
#include <functional> // Often included indirectly, sometimes needed explicitly

int main() {
    std::vector<int> numbers = {1, 5, 2, 8, 3, 7, 4, 6};
    int threshold = 4;
    std::vector<std::string> words = {"C++", "is", "powerful", "and", "fun"};

    // --- std::find_if ---
    // Find the first element greater than 'threshold'
    // [threshold] captures 'threshold' by copy. (int n) is the parameter passed by find_if.
    auto it_greater = std::find_if(numbers.begin(), numbers.end(),
                                   [threshold](int n) -> bool {
                                       return n > threshold;
                                   });

    if (it_greater != numbers.end()) {
        std::cout << "First element > " << threshold << ": " << *it_greater << std::endl; // Output: 5
    }

    // --- std::count_if ---
    // Count how many elements are even
    // [] captures nothing. Lambda only uses its parameter 'n'.
    size_t even_count = std::count_if(numbers.begin(), numbers.end(),
                                      [](int n) { return n % 2 == 0; }); // -> bool deduced
    std::cout << "Number of even elements: " << even_count << std::endl; // Output: 4

    // --- std::sort (with custom comparator) ---
    // Sort words by length (shortest first)
    // Takes two arguments, returns true if first should come before second
    std::sort(words.begin(), words.end(),
              [](const std::string& a, const std::string& b) {
                  return a.length() < b.length();
              });

    std::cout << "Words sorted by length:";
    for (const auto& w : words) std::cout << " " << w;
    std::cout << std::endl; // Output: is and fun C++ powerful

    // --- std::for_each ---
    // Apply an operation to each element (e.g., print with modification)
    // [&] captures by reference (though not needed here, just example)
    std::cout << "Printing numbers doubled:";
    std::for_each(numbers.begin(), numbers.end(),
                  [&](int n) {
                      std::cout << " " << (n * 2);
                  });
    std::cout << std::endl;

    // --- Capturing by Reference for Modification ---
    int sum = 0;
    std::cout << "Calculating sum (using reference capture):";
    // [&sum] captures 'sum' by reference, allowing the lambda to modify the original 'sum'
    std::for_each(numbers.begin(), numbers.end(),
                  [&sum](int n) {
                      sum += n;
                  });
    std::cout << " Sum = " << sum << std::endl; // Output: 36


    // --- Assigning lambda to a variable ---
    // Type is deduced by auto (it's some compiler-generated unnamed type)
    auto isOdd = [](int n) { return n % 2 != 0; };
    size_t odd_count = std::count_if(numbers.begin(), numbers.end(), isOdd);
    std::cout << "Number of odd elements: " << odd_count << std::endl; // Output: 4


    return 0;
}

#include <iostream>
#include <functional> // For std::function

std::function<void()> createPrinter(int val) {
    // [=] captures 'val' by copy when createPrinter is called
    return [=]() {
        std::cout << "Value captured by copy: " << val << std::endl;
    };
}

std::function<void()> createRefPrinter(int& val_ref) {
     // [&] captures 'val_ref' by reference when createRefPrinter is called
    return [&]() {
        std::cout << "Value captured by reference: " << val_ref << std::endl;
    };
}

int main() {
    int x = 10;
    auto printer1 = createPrinter(x); // Captures x=10 by copy

    int y = 20;
    auto printer2 = createRefPrinter(y); // Captures reference to y

    x = 11; // Change original x
    y = 22; // Change original y

    std::cout << "Calling printers after modification:\n";
    printer1(); // Prints 10 (captured the copy before x changed)
    printer2(); // Prints 22 (sees the change via reference)

    // Dangling reference example (DON'T DO THIS)
    std::function<void()> dangling_printer;
    {
       int z = 30;
       dangling_printer = createRefPrinter(z); // Captures reference to z
    } // z goes out of scope HERE!
    // dangling_printer(); // CALLING THIS IS UNDEFINED BEHAVIOR! The reference dangles.

    return 0;
}