Lambda Functions in C++

A lambda function in C++ is an anonymous, inline function object (a closure) that can capture variables from its surrounding scope. Lambdas were introduced in C++11 and have grown significantly more powerful in C++14, C++17, C++20, and C++23.

The general syntax is:

[capture](parameters) specifiers -> return_type { body }

A simple example:

auto square = [](int x) { return x * x; };
std::cout << square(5);  // 25

The compiler generates an unnamed class with an operator() for each lambda — lambdas are syntactic sugar for callable objects, not raw function pointers.

Key components:

• Capture list []: specifies which variables from the enclosing scope the lambda can use (by value =, by reference &, or named captures).
• Parameter list: same as a regular function; can use auto for generic lambdas (C++14+).
• Specifiers: mutable allows modifying captured-by-value variables; noexcept marks the call operator as non-throwing; consteval/constexpr (C++17/20) allow compile-time evaluation.
• Return type: usually deduced; can be explicit with -> T.

C++20 additions worth mentioning in interviews:

• Template lambdas: [](T x) { return x; } — explicit type parameters for generic lambdas.
• Lambdas in unevaluated contexts (e.g., decltype).
• [=] no longer captures this implicitly — you must write [=, this] explicitly.

Lambdas are the idiomatic way to pass behaviour to standard algorithms (std::sort, std::transform, std::ranges::filter) and are essential for writing concise, readable C++ today.

Variables from the enclosing scope are captured via the capture list [...] at the start of the lambda. There are several capture modes:

Capture by value (= or named) — the lambda gets its own copy at the point of creation:

int x = 10;
auto f = [x]() { return x * 2; };  // captures x by value
x = 99;
f();  // still returns 20 — captured the original value

Capture by reference (& or named &var) — the lambda refers to the original variable:

int count = 0;
auto inc = [&count]() { ++count; };
inc(); inc();
// count == 2

Default captures — apply to all implicitly used variables:

[=]   // capture everything by value
[&]   // capture everything by reference
[=, &x]  // everything by value except x (by reference)
[&, y]   // everything by reference except y (by value)

Capturing this in a member function:

// C++17 and earlier
auto f = [this]() { return member_; };

// C++20 — [=] no longer captures this implicitly; must be explicit:
auto f = [=, this]() { return member_; };

// C++17+ — capture a copy of *this (safe for async use):
auto f = [*this]() { return member_; };

mutable lambdas — by default, captured-by-value variables are const inside the lambda. mutable removes that restriction:

int x = 0;
auto f = [x]() mutable { x += 1; return x; };
f(); // returns 1 — modifies the lambda's own copy, not the original

C++14 init-captures (generalized capture) — create a new variable in the capture, useful for move-only types:

auto ptr = std::make_unique(42);
auto f = [p = std::move(ptr)]() { return *p; };
// ptr is now null; f owns the unique_ptr

Common interview pitfall: capturing a local variable by reference and then returning or storing the lambda past the variable's lifetime causes a dangling reference. Prefer capture by value or [*this] when the lambda may outlive the local scope.

Yes — lambdas and standard algorithms are designed to work together. Most algorithms in and accept a callable (function pointer, functor, or lambda) as a predicate or transformation argument. Lambdas are the most concise and readable way to supply that callable inline.

Classic `` usage:

#include 
#include 
#include 

std::vector v{5, 1, 4, 2, 3};

// Sort descending
std::sort(v.begin(), v.end(), [](int a, int b) { return a > b; });

// Filter: count elements greater than 3
int cnt = std::count_if(v.begin(), v.end(), [](int x) { return x > 3; });

// Transform: square each element
std::transform(v.begin(), v.end(), v.begin(), [](int x) { return x * x; });

// Print
std::for_each(v.begin(), v.end(), [](int x) { std::cout << x << ' '; });

C++20 Ranges make this even cleaner by removing the need to pass iterator pairs and by supporting lazy, composable pipelines:

#include 
#include 

std::vector v{1, 2, 3, 4, 5, 6};

// Lazy pipeline: filter evens, square them, print
for (int x : v | std::views::filter([](int n) { return n % 2 == 0; })
               | std::views::transform([](int n) { return n * n; })) {
    std::cout << x << ' ';   // 4 16 36
}

Ranges algorithms also accept the container directly instead of iterators:

std::ranges::sort(v, [](int a, int b) { return a > b; });
std::ranges::count_if(v, [](int x) { return x > 3; });

Why lambdas are preferred over named functors here: they are defined at the point of use, keep the intent local and readable, and are often inlined by the compiler — producing code as efficient as hand-written loops.

A generic lambda is a lambda whose parameter types are deduced, making it work across multiple types without specifying each one explicitly. It was introduced in C++14 using auto parameters.

C++14 generic lambda (auto parameters):

auto multiply = [](auto x, auto y) { return x * y; };

multiply(3, 4);        // int * int = 12
multiply(2.5, 4.0);   // double * double = 10.0
multiply(2, 3.5f);    // int * float = 7.0f

Under the hood, the compiler generates a template operator() inside the closure class — one instantiation per unique combination of argument types.

C++20 template lambdas give explicit control over type parameters, enabling relationships between parameters that auto cannot express:

// Require both parameters to be the same type
auto add = [](T a, T b) { return a + b; };

add(1, 2);      // OK — both int
// add(1, 2.0); // Error — deduction conflict

// Constrain with Concepts
auto sum_range = [](const R& r) {
    return std::ranges::fold_left(r, 0, std::plus{});
};

Practical uses:

// Generic comparator for sorting any comparable type
auto cmp = [](const auto& a, const auto& b) { return a < b; };
std::sort(v.begin(), v.end(), cmp);

// Generic printer
auto print = [](const auto& val) { std::cout << val << '\n'; };
print(42);
print("hello");
print(3.14);

Interview note: Generic lambdas (C++14+) are the idiomatic replacement for writing separate named function template objects. C++20 template lambdas further close the gap between lambdas and full function templates, allowing constraints, requires clauses, and explicit template argument lists.

Yes. Lambda functions can be stored in variables and passed as arguments, just like any other callable. The idiomatic way depends on the context.

Storing a lambda in auto:

auto square = [](int x) { return x * x; };
std::cout << square(5);  // 25

Storing in std::function — use this when you need to store a lambda that captures variables, store it in a container, or erase its exact type:

#include 

std::function transform = [](int x) { return x * 2; };
transform(7);  // 14

// Stored in a container
std::vector> callbacks;
callbacks.push_back([]{ std::cout << "hello\n"; });
callbacks.push_back([]{ std::cout << "world\n"; });
for (auto& cb : callbacks) cb();

Passing a lambda to a function — prefer a template parameter for maximum performance (avoids std::function overhead):

template 
void apply(const std::vector& v, Func f) {
    for (int x : v) f(x);
}

apply(v, [](int x) { std::cout << x << '\n'; });

C++20: using Concepts to constrain callable parameters:

template  Func>
void apply(const std::vector& v, Func f) {
    for (int x : v) f(x);
}

Trade-offs between auto and std::function:

C++23 std::move_only_function is a lighter alternative to std::function that supports move-only callables (e.g., lambdas that capture unique_ptr) and avoids unnecessary copies.