Mastering C++ Lambdas: From Basics to Advanced Techniques

In modern C++ programming, lambda expressions introduced in C++11 provide a concise way to define anonymous function objects, making code more elegant and efficient.

What is a Lambda expression?

A lambda expression is an anonymous function definition introduced in C++11 that can be defined directly where a callable is needed, especially useful for callbacks and algorithm parameters.

Basic syntax structure

The basic syntax of a lambda expression is:

[capture-list](parameter-list) mutable(optional) noexcept(optional) -> return-type(optional) { /* function body */ }

Example:

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

int main() {
    std::vector<int> numbers = {1,2,3,4,5,6,7,8,9,10};
    // Use a lambda to filter even numbers
    auto even_numbers = numbers | std::views::filter([](int n) {
        return n % 2 == 0;
    });
    for (auto num : even_numbers) {
        std::cout << num << " ";
    }
    // Output: 2 4 6 8 10
    return 0;
}

Capture list details

The capture list allows a lambda to access variables from its surrounding scope.

Value capture vs reference capture

#include <iostream>

int main() {
    int x = 10;
    int y = 20;
    // Value capture
    auto lambda1 = [x]() {
        std::cout << "Value capture: " << x << std::endl;
    };
    // Reference capture
    auto lambda2 = [&y]() {
        std::cout << "Reference capture: " << y << std::endl;
        y++; // modify original variable
    };
    lambda1(); // prints 10
    lambda2(); // prints 20 and y becomes 21
    return 0;
}

Implicit capture

#include <iostream>

int main() {
    int a = 5, b = 10, c = 15;
    // Implicit value capture
    auto lambda1 = [=]() { std::cout << a << ", " << b << ", " << c << std::endl; };
    // Implicit reference capture
    auto lambda2 = [&]() { a++; b++; c++; std::cout << a << ", " << b << ", " << c << std::endl; };
    // Mixed capture: value for a, reference for b
    auto lambda3 = [=, &b]() { b++; std::cout << a << ", " << b << std::endl; };
    lambda1(); // 5, 10, 15
    lambda2(); // 6, 11, 16
    lambda3(); // 6, 12
    return 0;
}

mutable keyword

By default, variables captured by value are const inside the lambda; adding mutable removes this constness.

#include <iostream>

int main() {
    int count = 0;
    auto counter = [count]() mutable {
        count++;
        std::cout << "Count: " << count << std::endl;
        return count;
    };
    counter(); // Count: 1
    counter(); // Count: 2
    counter(); // Count: 3
    std::cout << "Original count: " << count << std::endl; // Original count: 0
    return 0;
}

Return type deduction

Lambdas can deduce the return type automatically or specify it explicitly.

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

int main() {
    std::vector<int> numbers = {1,2,3,4,5};
    // Automatic deduction
    auto square = [](int x) { return x * x; };
    // Explicit return type
    auto safe_divide = [](double a, double b) -> double {
        if (b == 0) return 0;
        return a / b;
    };
    for (int n : numbers) {
        std::cout << square(n) << " ";
    }
    std::cout << std::endl;
    std::cout << safe_divide(10, 3) << std::endl; // 3.33333
    return 0;
}

Generic Lambda (C++14)

C++14 allows generic lambdas using auto as parameter types.

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

int main() {
    auto add = [](auto a, auto b) { return a + b; };
    std::cout << add(10, 20) << std::endl; // 30
    std::cout << add(3.14, 2.71) << std::endl; // 5.85
    std::cout << add(std::string("Hello"), std::string(" World")) << std::endl; // Hello World
    return 0;
}

Application in STL algorithms

Lambdas integrate smoothly with STL algorithms, improving readability.

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

int main() {
    std::vector<int> numbers = {5,2,8,1,9,3,7,4,6};
    // Sort descending
    std::sort(numbers.begin(), numbers.end(), [](int a, int b) { return a > b; });
    std::cout << "Descending: ";
    for (int n : numbers) std::cout << n << " ";
    std::cout << std::endl;
    // Find first element greater than 5
    auto it = std::find_if(numbers.begin(), numbers.end(), [](int n) { return n > 5; });
    if (it != numbers.end())
        std::cout << "First >5: " << *it << std::endl;
    // Compute average
    double sum = std::accumulate(numbers.begin(), numbers.end(), 0);
    double average = sum / numbers.size();
    // Count elements greater than average
    int count = std::count_if(numbers.begin(), numbers.end(), [average](int n) { return n > average; });
    std::cout << "Average: " << average << std::endl;
    std::cout << "Elements > average: " << count << std::endl;
    return 0;
}

Capture *this (C++17)

C++17 permits capturing *this by value or reference.

#include <iostream>

class Processor {
private:
    int base_value;
public:
    Processor(int value) : base_value(value) {}
    auto create_multiplier() {
        // Capture *this by value
        return [*this](int factor) { return base_value * factor; };
    }
};

int main() {
    Processor processor(10);
    auto multiplier = processor.create_multiplier();
    std::cout << "Result: " << multiplier(5) << std::endl; // 50
    return 0;
}

Template Lambda (C++20)

C++20 adds support for templated lambdas.

#include <iostream>
#include <vector>
#include <list>

int main() {
    // Template lambda
    auto print_container = []<typename T>(const T& container) {
        for (const auto& item : container) {
            std::cout << item << " ";
        }
        std::cout << std::endl;
    };
    std::vector<int> vec = {1,2,3,4,5};
    std::list<std::string> lst = {"A","B","C","D"};
    print_container(vec); // 1 2 3 4 5
    print_container(lst); // A B C D
    return 0;
}

Practical scenarios

1. Event handling

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

class Button {
private:
    std::vector<std::function<void()>> click_handlers;
public:
    void add_click_handler(std::function<void()> handler) {
        click_handlers.push_back(handler);
    }
    void click() {
        for (auto& handler : click_handlers) {
            handler();
        }
    }
};

int main() {
    Button button;
    int click_count = 0;
    // Add lambda as event handler
    button.add_click_handler([&click_count]() {
        click_count++;
        std::cout << "Button clicked! Count: " << click_count << std::endl;
    });
    button.click(); // Count: 1
    button.click(); // Count: 2
    return 0;
}

2. Asynchronous programming

#include <iostream>
#include <future>
#include <thread>
#include <chrono>

int main() {
    // Launch async task with a lambda
    auto future = std::async(std::launch::async, []() {
        std::this_thread::sleep_for(std::chrono::seconds(2));
        return "Async task completed!";
    });
    std::cout << "Main thread continues..." << std::endl;
    // Wait for async task
    std::string result = future.get();
    std::cout << result << std::endl; // Async task completed!
    return 0;
}

Best practices and considerations

Avoid excessive reference capture, especially of short‑lived variables.

Prefer value capture unless you need to modify external state.

Be aware of performance: simple lambdas are usually inlined by the compiler.

Keep lambdas short; move complex logic to named functions.

Summary

Lambda expressions are an indispensable feature of modern C++ that enable more concise code, flexible programming, better performance, and seamless integration with STL algorithms.

Cleaner code: reduces boilerplate and improves readability.

Greater flexibility: easy creation of anonymous function objects.

Performance benefits: compilers can optimize lambdas effectively.

Expressiveness: work naturally with STL algorithms.