C++ Lambda Expressions Explained — Captures, Closures and Performance Traps

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

// ── What YOU write ──────────────────────────────────────────────
// A lambda that captures 'threshold' by value and 'label' by reference.
auto make_filter_lambda(int threshold, std::string& label) {
    return [threshold, &label](int value) -> bool {
        // 'threshold' is a COPY stored inside the closure object.
        // 'label' is a REFERENCE — if 'label' dies, this is UB.
        std::cout << "[" << label << "] Checking " << value
                  << " against " << threshold << "\n";
        return value > threshold;
    };
}

// ── What the COMPILER roughly generates ─────────────────────────
// This is the anonymous class the compiler creates for the lambda above.
class __lambda_closure_equivalent {
public:
    // Captured-by-value becomes a data member (copy on construction).
    int threshold_copy;
    // Captured-by-reference becomes a reference member.
    std::string& label_ref;

    // The constructor captures at the point the lambda is created.
    __lambda_closure_equivalent(int t, std::string& l)
        : threshold_copy(t), label_ref(l) {}

    // operator() IS your lambda body.
    bool operator()(int value) const {
        std::cout << "[" << label_ref << "] Checking " << value
                  << " against " << threshold_copy << "\n";
        return value > threshold_copy;
    }
    // NOTE: no implicit function-pointer conversion because
    // this closure captures variables (non-empty capture list).
};

int main() {
    std::string category = "temperature";
    int limit = 37;

    auto filter = make_filter_lambda(limit, category);

    std::vector<int> readings = {35, 38, 36, 41, 37};

    // std::copy_if uses the lambda's operator() on each element.
    std::vector<int> above_threshold;
    std::copy_if(readings.begin(), readings.end(),
                 std::back_inserter(above_threshold), filter);

    std::cout << "Readings above threshold: ";
    for (int r : above_threshold) std::cout << r << " ";
    std::cout << "\n";

    // Demonstrating empty-capture lambda converts to function pointer.
    auto pure_double = [](int n) { return n * 2; };
    int (*fn_ptr)(int) = pure_double;  // OK — empty capture list.
    std::cout << "Via function pointer: " << fn_ptr(21) << "\n";

    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <functional>

// Demonstrates named capture, mutable, and the 'this' capture trap.
class SensorProcessor {
public:
    std::string device_name;
    int alert_count = 0;

    SensorProcessor(std::string name) : device_name(std::move(name)) {}

    // Returns a lambda that counts how many times it fires.
    // 'mutable' is required because we modify the captured 'local_count'.
    auto make_alert_counter(int initial_count) {
        // Named capture: only 'initial_count' copied, nothing else.
        // 'mutable' lifts the const from operator() so we can write
        // to the closure's copy of 'local_count'.
        return [local_count = initial_count]() mutable {
            ++local_count;  // Modifies the CLOSURE's copy, not the original.
            std::cout << "Alert fired. Internal count: " << local_count << "\n";
            return local_count;
        };
    }

    // THE 'this' TRAP — [=] in a member function captures 'this' (a pointer),
    // not a copy of the object. Mutations through 'device_name' still
    // affect the live object, because we have its raw pointer.
    std::function<void()> make_name_printer_unsafe() {
        return [=]() {
            // This looks like a value capture of device_name, but
            // it's actually dereferencing captured 'this'.
            std::cout << "Device (via captured this): " << device_name << "\n";
        };
    }

    // SAFE VERSION — capture 'device_name' by value explicitly (C++14+).
    std::function<void()> make_name_printer_safe() {
        // Init-capture creates a true independent copy of device_name.
        return [name_copy = device_name]() {
            std::cout << "Device (own copy): " << name_copy << "\n";
        };
    }
};

int main() {
    // ── mutable lambda demo ──────────────────────────────────────
    SensorProcessor processor("ThermalSensor-7");
    auto counter = processor.make_alert_counter(10);

    counter();  // Internal count: 11
    counter();  // Internal count: 12
    counter();  // Internal count: 13

    // ── 'this' trap demo ─────────────────────────────────────────
    auto unsafe_printer = processor.make_name_printer_unsafe();
    auto safe_printer   = processor.make_name_printer_safe();

    // Mutate the original object AFTER the lambdas were created.
    processor.device_name = "RENAMED-SENSOR";

    // unsafe_printer sees the new name because it holds 'this'.
    unsafe_printer();  // Device (via captured this): RENAMED-SENSOR
    // safe_printer holds its own copy — immune to the rename.
    safe_printer();    // Device (own copy): ThermalSensor-7

    // ── hidden copy cost demo ─────────────────────────────────────
    std::vector<int> big_data(100'000, 42);  // 100K ints

    // BAD: [=] copies ALL of big_data into the closure — 400KB on the heap.
    auto expensive_lambda = [=]() { return big_data.size(); };

    // GOOD: capture only the size, not the data.
    std::size_t data_size = big_data.size();
    auto cheap_lambda = [data_size]() { return data_size; };

    std::cout << "Expensive lambda result: " << expensive_lambda() << "\n";
    std::cout << "Cheap lambda result:     " << cheap_lambda()     << "\n";

    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <functional>
#include <chrono>
#include <map>

// ── Generic lambda (C++14) ───────────────────────────────────────
// The compiler generates a templated operator() — one instantiation
// per unique argument type it's called with.
auto print_with_label = [](const auto& label, const auto& value) {
    std::cout << label << ": " << value << "\n";
};

// ── Explicit template lambda (C++20) ────────────────────────────
// Gives you the full power of a function template: constraints, SFINAE,
// access to T inside the body.
auto typed_sum = []<typename T>(const std::vector<T>& items) -> T {
    T total{};
    for (const auto& item : items) total += item;
    return total;
};

// ── Recursive lambda using std::function ────────────────────────
// Self-reference requires type-erased storage — the lambda's closure
// holds a std::function<> by reference to call itself.
std::function<long long(int)> make_fibonacci() {
    // Memoization map captured by value — owned by this closure.
    return [memo = std::map<int, long long>{}](int n) mutable -> long long {
        // We can't recurse using our own name here.
        // Pattern: use a helper that accepts 'self' as a parameter.
        // For simple recursion via std::function, we store the function
        // as a named variable and capture it by reference.
        // (See the Y-combinator pattern below for the cleaner version.)
        if (n <= 1) return n;
        if (memo.count(n)) return memo[n];
        // This won't work without self-reference — shown for context.
        // Use the Y-combinator pattern below instead.
        return n; // placeholder
    };
}

// ── Y-combinator pattern — the idiomatic recursive lambda ────────
// 'self' receives the lambda itself, enabling true recursion without
// std::function overhead on the recursive call path.
auto fibonacci_fast = [](auto& self, int n, auto& memo) -> long long {
    if (n <= 1) return n;
    if (memo.count(n)) return memo[n];
    memo[n] = self(self, n - 1, memo) + self(self, n - 2, memo);
    return memo[n];
};

// ── std::function overhead benchmark ────────────────────────────
void benchmark_std_function_vs_template() {
    constexpr int iterations = 10'000'000;
    int accumulator = 0;

    // Using std::function — type-erased, heap-allocated closure possible,
    // virtual dispatch on every call.
    std::function<int(int)> erased_doubler = [](int n) { return n * 2; };

    auto t1 = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < iterations; ++i)
        accumulator += erased_doubler(i);
    auto t2 = std::chrono::high_resolution_clock::now();

    auto ms_erased = std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count();

    // Using auto (direct closure type) — compiler can inline, no dispatch.
    auto direct_doubler = [](int n) { return n * 2; };
    accumulator = 0;

    auto t3 = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < iterations; ++i)
        accumulator += direct_doubler(i);
    auto t4 = std::chrono::high_resolution_clock::now();

    auto ms_direct = std::chrono::duration_cast<std::chrono::milliseconds>(t4 - t3).count();

    std::cout << "std::function  (10M calls): " << ms_erased << " ms\n";
    std::cout << "auto lambda    (10M calls): " << ms_direct << " ms\n";
    std::cout << "(accumulator: " << accumulator << " — prevents dead-code elimination)\n";
}

int main() {
    // Generic lambda — works with int, double, string.
    print_with_label("Altitude", 3048);
    print_with_label("Pressure", 1013.25);
    print_with_label("Status",   std::string("nominal"));

    // Typed template lambda.
    std::vector<int>    int_readings   = {10, 20, 30, 40};
    std::vector<double> float_readings = {1.1, 2.2, 3.3};
    std::cout << "Int sum:    " << typed_sum(int_readings)   << "\n";
    std::cout << "Double sum: " << typed_sum(float_readings) << "\n";

    // Y-combinator recursive fibonacci with memoization.
    std::map<int, long long> fib_memo;
    std::cout << "Fibonacci(40): "
              << fibonacci_fast(fibonacci_fast, 40, fib_memo) << "\n";

    // Benchmark.
    benchmark_std_function_vs_template();

    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <future>
#include <thread>
#include <memory>
#include <chrono>

// ── Pattern 1: IIFE for complex const initialization ─────────────
// The lambda is created AND called immediately — the () at the end.
// This lets us write branching const-init without a helper function.
std::string determine_environment() {
    // Pretend we're reading from config/env.
    bool is_debug_build  = true;
    bool has_gpu_support = false;

    // Without IIFE we'd need mutable string + if/else, or a named function.
    const std::string runtime_mode = [&]() -> std::string {
        if (is_debug_build && has_gpu_support) return "debug-gpu";
        if (is_debug_build)                    return "debug-cpu";
        if (has_gpu_support)                   return "release-gpu";
        return "release-cpu";
    }();  // <── the () invokes the lambda immediately

    return runtime_mode;  // const, initialized exactly once, no mutation needed.
}

// ── Pattern 2: Safe async lambda — move capture of shared state ──
void run_async_processing() {
    // Shared ownership: both the main thread and the async task are valid
    // owners. The data lives as long as either party holds a reference.
    auto shared_dataset = std::make_shared<std::vector<int>>(
        std::vector<int>{5, 1, 9, 3, 7, 2, 8, 4, 6}
    );

    // Move the shared_ptr INTO the lambda — the lambda owns a ref-count.
    // The original 'shared_dataset' is now empty. No dangling reference possible.
    auto future_result = std::async(std::launch::async,
        [dataset = std::move(shared_dataset)]() mutable -> std::vector<int> {
            // Safe: dataset is a shared_ptr we own.
            std::sort(dataset->begin(), dataset->end());
            std::cout << "[async task] Sorted " << dataset->size()
                      << " elements.\n";
            return *dataset;
        }
    );

    // Do other work on the main thread while the task runs...
    std::cout << "[main thread] Doing other work...\n";

    auto sorted = future_result.get();
    std::cout << "[main thread] Sorted result: ";
    for (int v : sorted) std::cout << v << " ";
    std::cout << "\n";
}

// ── Pattern 3: Custom comparator inline — compiler can inline it ──
struct LogEntry {
    std::string level;     // "ERROR", "WARN", "INFO"
    int         timestamp;
    std::string message;
};

void sort_log_entries(std::vector<LogEntry>& entries) {
    // Sort by level priority first, then by timestamp descending.
    // Defined right here — no hunting for a separate comparator function.
    std::sort(entries.begin(), entries.end(),
        [](const LogEntry& a, const LogEntry& b) {
            // Define severity inline — readable at the call site.
            auto severity = [](const std::string& lvl) {
                if (lvl == "ERROR") return 3;
                if (lvl == "WARN")  return 2;
                return 1; // INFO
            };
            if (severity(a.level) != severity(b.level))
                return severity(a.level) > severity(b.level);  // Higher severity first.
            return a.timestamp > b.timestamp;                  // Newer first within same level.
        }
    );
}

int main() {
    // IIFE demo.
    std::cout << "Runtime mode: " << determine_environment() << "\n";

    // Async safe capture demo.
    run_async_processing();

    // Inline sort comparator demo.
    std::vector<LogEntry> logs = {
        {"INFO",  1000, "Server started"},
        {"ERROR", 1005, "Disk full"},
        {"WARN",  1002, "Memory low"},
        {"ERROR", 1010, "Segfault in worker"},
        {"INFO",  1008, "Request received"},
    };
    sort_log_entries(logs);
    std::cout << "\nSorted log entries:\n";
    for (const auto& entry : logs)
        std::cout << "  [" << entry.level << " @" << entry.timestamp
                  << "] " << entry.message << "\n";

    return 0;
}