Modern C++11 - Day 9: Lambda Capture by Reference

After learning lambda capture by reference, you should understand:

1. What capture by reference means.
2. How it differs from capture by value.
3. When to use [&x] and [&].
4. Common mistakes with dangling references.
5. How reference capture is used in real-world C++ code.

Capture by value gives the lambda a copy of an outside variable.

Capture by reference lets the lambda use the original variable directly.

int total = 0;

auto add = [&total](int x) {
    total += x;
};

Main idea:

Capture by reference allows a lambda to read or modify the original outside variable.

Capture one variable by reference:

[&x]() {
    x += 1;
};

Capture multiple variables by reference:

[&a, &b]() {
    a += 1;
    b += 1;
};

Capture all used outside variables by reference:

[&]() {
    total += 1;
};

Basic meaning:

[]       = capture nothing
[x]      = capture x by value
[&x]     = capture x by reference
[=]      = capture all used outside variables by value
[&]      = capture all used outside variables by reference

Capture by value:

int threshold = 1000;

auto f = [threshold]() {
    return threshold;
};

threshold = 2000;

The lambda still sees 1000.

Capture by reference:

int threshold = 1000;

auto f = [&threshold]() {
    return threshold;
};

threshold = 2000;

The lambda sees 2000.

Summary:

Capture by value     = snapshot copy
Capture by reference = access original variable

5.1. Dangling reference

Do not return a lambda that captures a local variable by reference.

auto makeLambda() {
    int x = 10;
    return [&x]() {
        return x;
    };
}

After the function ends, x no longer exists. The lambda holds a broken reference.

5.2. Accidental modification

int threshold = 1000;

auto f = [&threshold]() {
    threshold = 2000;
};

Because the lambda captures by reference, it modifies the original variable.

5.3. Overusing [&]

auto f = [&]() {
    // uses many outside variables
};

This can make it unclear which variables the lambda depends on or modifies.

Prefer explicit captures when clarity matters:

auto f = [&total, threshold]() {
    // total by reference, threshold by value
};

Use capture by reference when:

1. You need to modify an outside variable.
2. You want the lambda to see updated values.
3. You want to avoid copying a large object.
4. The lambda will not outlive the referenced variables.

Avoid it when:

1. The lambda may outlive the referenced variables.
2. You want a stable snapshot.
3. Accidental modification would be dangerous.

Trading code may use reference capture to accumulate results:

Total volume
Total notional
Risk counters
Statistics

Example idea:

double totalNotional = 0.0;

auto addNotional = [&totalNotional](const Trade& trade) {
    totalNotional += trade.price * trade.quantity;
};

This modifies the original totalNotional.

Be careful with lambdas stored for later execution, callbacks, or threads.

You should remember:

[&x] = capture x by reference
[&]  = capture all used outside variables by reference

You should be able to answer:

1. What is the difference between [x] and [&x]?
2. When does capture by reference see updated values?
3. Why can dangling references be dangerous?
4. When should you avoid [&]?
5. Why is reference capture useful for accumulation?

Capture by reference lets a lambda access the original outside variables.

The key idea:

Use capture by reference when you need shared access or modification.
Be careful with lifetime and accidental mutation.

:::