Lambda expressions — capture list (by value, by reference)

WHAT is a lambda + capture list?

Definition Lambda expression

A lambda is an anonymous function object. Full anatomy: $\underbrace{[\,\text{capture}\,]}_{\text{capture list}}\ \underbrace{(\,\text{params}\,)}_{\text{like fn args}}\ \underbrace{\text{mutable}}_{\text{optional}}\ \underbrace{\to \text{ret}}_{\text{optional}}\ \{\ \text{body}\ \}$

auto add = [](int a, int b){ return a + b; };  // [] = captures nothing
add(2, 3); // 5

WHY does this exist? (first principles)

A lambda

int n = 10;
auto f = [n](int x){ return x + n; };

is compiled to roughly:

struct __Lambda {
    int n;                       // captured BY VALUE -> stored as a member (a COPY)
    int operator()(int x) const  // const! that's why by-value is read-only by default
    { return x + n; }
};
__Lambda f{ n };                 // n copied into the struct at creation time

Now compare by reference:

auto g = [&n](int x){ return x + n; };
// struct { int& n; int operator()(int x) const { return x + n; } };

The member is a reference int& — an alias to the original n. So g always sees the current value of n.

Figure — Lambda expressions — capture list (by value, by reference)

HOW to use it — worked examples

Worked example 1. By value = snapshot

int n = 1;
auto f = [n]() { return n; };   // copies n=1 NOW
n = 99;                          // change original
std::cout << f();                // prints 1

Why this step? The copy was made at the [n] line when n was 1. Later assigning n = 99 edits the outside variable only; the lambda's private copy is untouched.

Worked example 2. By reference = live link

int n = 1;
auto g = [&n]() { return n; };  // stores &n
n = 99;
std::cout << g();                // prints 99

Why this step? [&n] stores the address. When g() runs it reads whatever is in that memory now — and we just wrote 99 there.

Worked example 3.

mutable — editing a by-value copy

int n = 10;
auto c = [n]() mutable { n++; return n; };  // edits the COPY
std::cout << c();   // 11
std::cout << c();   // 12  (copy persists between calls)
std::cout << n;     // 10  (original never changed)

Why this step? By default operator() is const, so the by-value member can't be modified. mutable drops the const, letting you change the internal copy. The original n is a different object, so it stays 10.

Worked example 4. A stateful counter (the classic use)

int count = 0;
auto tick = [&count]() { ++count; };
tick(); tick(); tick();
std::cout << count;   // 3

Why this step? We want the lambda to affect the outside world (accumulate). By reference is exactly the tool: it mutates the real count.

Worked example 5. Mixing defaults

int a = 1, b = 2;
auto m = [=, &b]() mutable { a += 10; b += 10; return a + b; };
// a captured by value (copy), b by reference (live)
m();                 // copy a=11, b becomes 12 -> returns 23
std::cout << a;      // 1  (copy edited, not original)
std::cout << b;      // 12 (original edited via reference)

Why this step? [=, &b] means "default by value, except b by reference." So a is a private copy; b is the real thing.

The dangling-reference trap

Common mistake "By reference is always better — it avoids copies."

Why it feels right: copying is expensive, references are free, so reflexively using [&] seems efficient and clean. Why it's dangerous: if the lambda outlives the captured variable, the reference dangles → undefined behavior.

auto make() {
    int x = 42;
    return [&x]() { return x; };  // BUG: x dies when make() returns!
}
auto bad = make();
bad();   // reads dead memory — UB

Fix: capture by value when the lambda escapes the scope (stored, returned, passed to async/threads). Use [x] (or [=]) so the value lives inside the lambda.

Recall Feynman: explain to a 12-year-old

Imagine you're packing a lunchbox (the lambda) to use later. You can either put an actual sandwich inside (by value) — it's yours, fully portable, but it's the sandwich as it was when you packed it. Or you can tape a note saying "ask Mom for the sandwich in the kitchen" (by reference) — you always get the freshest one, but if Mom goes on vacation (the variable's scope ends), your note points to an empty kitchen and you get nothing (a crash). So: carry it with you → put the real thing in (value). Stay near the kitchen and want it fresh → keep the note (reference).

Active recall

What does the capture list [...] of a lambda specify?

Which enclosing-scope local variables the lambda may use, and how (by value=copy, or by reference=alias).

By value [x] vs by reference [&x]: which sees later changes to the original?

By reference [&x] sees the current (live) value; by value [x] keeps the frozen snapshot from creation time.

What is a lambda compiled into?

An anonymous class (closure type) with an operator(); captures become its member variables.

Why can't you modify a by-value captured variable inside a lambda by default?

Because operator() is const by default; the captured copy is a const member. Use mutable to allow editing the copy.

Does mutable editing a by-value capture change the original variable?

No — it changes the lambda's internal copy only; the original is untouched.

What does [=] capture?

Everything the body actually uses, by value (copies).

What does [&] capture?

Everything the body actually uses, by reference (aliases).

What does [=, &y] mean?

Default capture by value, but y specifically by reference.

What is the main danger of capturing by reference?

Dangling reference / UB if the lambda outlives the captured variable's scope (e.g., returned, stored, used async).

When the lambda escapes its scope, which capture should you prefer?

By value, so the data lives inside the lambda's own storage.

What does [this] capture?

The enclosing object's this pointer, letting the lambda access its members.

Connections

Function objects (functors) — a lambda is a compiler-generated functor.
std::function — type-erased wrapper that can hold any lambda.
References vs pointers in C++ — explains the int& member behind [&x].
Object lifetime and scope — the root of the dangling-reference trap.
const member functions — why by-value captures are read-only by default.
std::thread and async — classic place where by-reference capture goes wrong.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, lambda ek chhoti si anonymous function hoti hai jise tum inline likh dete ho. Iska asli jaadu hai capture list [...] — yeh batati hai ki bahar ke (enclosing scope ke) kaunse variables yeh lambda use kar sakti hai, aur kaise. Compiler internally har lambda ko ek hidden struct bana deta hai jiska operator() hota hai, aur captures us struct ke member variables ban jaate hain. Bas yahi ek idea samajh lo, sab clear ho jayega.

By value [n] ka matlab — lambda ke andar n ki ek copy ban jaati hai, creation ke time pe. Soch lo ek photo kheench li. Baad mein bahar wala n change ho jaye, koi farak nahi — tumhari photo waisi hi rahegi (frozen snapshot). By reference [&n] ka matlab — lambda n ka address store karti hai, ek phone line ki tarah. Jab bhi call karoge, original n ki current value milegi.

Ek important baat: by-value capture default mein read-only hoti hai, kyunki operator() const hota hai. Agar copy ko andar modify karna ho to mutable lagao — lekin tab bhi sirf copy badlegi, original nahi. Aur sabse bada trap: by reference tab use mat karo jab lambda apne scope se bahar ja rahi ho (return ho rahi, stored ho rahi, ya thread/async ko di ja rahi). Variable mar jayega, reference dangling ho jayegi, aur program crash (undefined behavior). Aise case mein hamesha by value capture karo taaki data lambda ke andar zinda rahe.

Yaad rakhne ka formula: Value = photo (safe to carry, frozen), Reference = phone line (fresh, but useless agar banda chala gaya). Exams aur real interviews dono mein yeh dangling-reference wala point bahut poocha jaata hai.

Lambda expressions — capture list (by value, by reference)

WHAT is a lambda + capture list?

WHY does this exist? (first principles)

HOW to use it — worked examples

The dangling-reference trap

Active recall

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — C++ Programming

Connections