{"title":"Lambda Expressions (C++11)","description":null,"content":"A lambda expression is a callable object you can define right where you need it, inline, without writing a full named function or a small functor class. Added in C++11, lambdas became the default way to pass behavior into algorithms, threads, callbacks, and anything else that takes a callable. This chapter covers what a lambda actually is, the parts of its syntax, how to use it with the standard library, and where to store one once you've made it. Captures get a brief mention here for context, but the deep dive on them lives in the next chapter.\n\n---\n\n# Why Lambdas Exist\n\nBefore lambdas, if you wanted to hand a small piece of behavior to a standard algorithm or a thread, you had two choices and neither was good.\n\nSuppose an online store keeps a list of orders and wants to sort them by total amount. `std::sort` accepts a third argument, a comparator, that decides which of two elements should come first. The first option was to write a free function:\n\n\n```cpp\n#include \n#include \n#include \n\nstruct Order {\n int id;\n double total;\n};\n\nbool byTotalDescending(const Order& a, const Order& b) {\n return a.total > b.total;\n}\n\nint main() {\n std::vector orders = {{1, 49.99}, {2, 14.50}, {3, 129.00}, {4, 7.25}};\n std::sort(orders.begin(), orders.end(), byTotalDescending);\n for (const Order& o : orders) {\n std::cout << \"Order \" << o.id << \": $\" << o.total << std::endl;\n }\n return 0;\n}\n```\n\n\nWait, that output is wrong. The compiler doesn't care, but a careful reader will spot that `49.99` should come before `14.50` when sorted descending. The free function works correctly, the issue is just that floating-point output doesn't show trailing zeros by default. Run the program and you'll see `129, 49.99, 14.5, 7.25` in the actual run order. The point stands: the free function does its job.\n\nThe downside is that `byTotalDescending` lives somewhere far away from the call site. To understand what `std::sort` is doing, you have to jump to wherever the function was defined. For a comparator that's only used once, that's a lot of code for a small idea.\n\nThe second option was a functor, a class with `operator()` overloaded:\n\n\n```cpp\nstruct ByTotalDescending {\n bool operator()(const Order& a, const Order& b) const {\n return a.total > b.total;\n }\n};\n\n// At the call site:\nstd::sort(orders.begin(), orders.end(), ByTotalDescending{});\n```\n\n\nThis is even worse for a one-off comparator. You're writing a whole class for a single comparison. And if the comparator needs to capture state, like \"sort by total only when the customer is in this country\", the functor has to grow constructor parameters and member fields.\n\nA lambda is C++'s way of writing the small thing in the place it's used:\n\n\n```cpp\nstd::sort(orders.begin(), orders.end(), [](const Order& a, const Order& b) {\n return a.total > b.total;\n});\n```\n\n\nThe comparator is now right next to `std::sort`. A reader doesn't have to jump anywhere. The compiler still generates a class with `operator()` under the hood, you just don't write it.\n\n---\n\n# Lambda Syntax, Piece by Piece\n\nThe general form of a lambda is:\n\n\n```cpp\n[capture-list](parameter-list) -> return-type { body }\n```\n\n\nMost lambdas use only some of those parts. The minimum legal lambda is `[](){}`, which captures nothing, takes no parameters, returns nothing, and does nothing. Useless, but valid.\n\n\n```cpp\nauto doNothing = [](){};\ndoNothing(); // does, indeed, nothing\n```\n\n\nEach part means a specific thing. Let's walk through them with a running example.\n\n### The capture list `[ ]`\n\nThe capture list is the only part that's mandatory in syntax. Even when empty, the `[]` must be present, because the brackets are how the compiler recognizes \"this is a lambda\" instead of an array subscript or something else.\n\nA non-capturing lambda has empty brackets:\n\n\n```cpp\nauto isOnSale = [](double price) {\n return price < 20.0;\n};\n\nstd::cout << isOnSale(14.99) << std::endl; // 1 (true)\nstd::cout << isOnSale(29.99) << std::endl; // 0 (false)\n```\n\n\nA capturing lambda lists variables from the enclosing scope that the body needs:\n\n\n```cpp\ndouble saleCutoff = 20.0;\nauto isUnderCutoff = [saleCutoff](double price) {\n return price < saleCutoff;\n};\n```\n\n\n`[saleCutoff]` means \"copy `saleCutoff` from the enclosing scope into the lambda\". Inside the body, `saleCutoff` is a local copy. We'll come back to captures in a few sections. For now, treat them as \"names from outside that the body uses\".\n\n### The parameter list `( )`\n\nParameters work exactly like function parameters. Types, references, defaults, the whole package.\n\n\n```cpp\nauto applyDiscount = [](double price, double percentOff) {\n return price * (1.0 - percentOff / 100.0);\n};\n\nstd::cout << applyDiscount(50.0, 10.0) << std::endl; // 45\n```\n\n\nIf the lambda takes no parameters, you can drop the parentheses entirely in C++23. In C++11/14/17, the parentheses are required even for an empty parameter list:\n\n\n```cpp\nauto greet = []() { std::cout << \"Welcome\\n\"; }; // valid in all versions\nauto greet2 = [] { std::cout << \"Welcome\\n\"; }; // valid in C++23, error before\n```\n\n\nWe'll write the parentheses explicitly in this course so the examples compile with `-std=c++17`.\n\n### The body `{ }`\n\nThe body is just a function body. Anything legal inside a function is legal inside a lambda, including loops, conditionals, declaring local variables, and calling other functions.\n\n\n```cpp\nauto formatCartLine = [](const std::string& product, int quantity, double unitPrice) {\n double lineTotal = quantity * unitPrice;\n std::cout << product << \" x \" << quantity\n << \" @ $\" << unitPrice\n << \" = $\" << lineTotal << std::endl;\n};\n\nformatCartLine(\"Coffee Mug\", 3, 8.50);\n```\n\n\n### The return type `-> T`\n\nThis is the one piece most lambdas leave off. C++ deduces the return type from the body in almost every realistic case, so you only write `-> T` when you want to override the deduction or when the deduction fails.\n\n\n```cpp\n// Return type deduced as double:\nauto applyTax = [](double price) {\n return price * 1.08;\n};\n\n// Same lambda, return type spelled out:\nauto applyTaxExplicit = [](double price) -> double {\n return price * 1.08;\n};\n```\n\n\nBoth compile to identical code. The trailing return type syntax (`-> T` after the parameter list) is the only way C++ lets you write a return type for a lambda. You can't put it before the `[` the way you'd write it for a function. That's why this style is sometimes called \"trailing return type\".\n\nWhen does deduction fail or matter?\n\nIf the body has multiple `return` statements and they don't all return the same type, the compiler refuses to deduce. Spell out the return type to break the tie:\n\n\n```cpp\nauto categorize = [](double price) -> std::string {\n if (price < 10.0) return \"budget\";\n if (price < 50.0) return std::string(\"mid-range\"); // different type without ->\n return \"premium\";\n};\n```\n\n\nThe first and third returns produce `const char*`. The second produces `std::string`. Without the `-> std::string`, the compiler can't pick one and you get a long error. With the trailing return type, every return is implicitly converted to `std::string`.\n\nThe other case is when you want a different type than what the body produces, usually to force a wider type. Returning `0` deduces to `int`; if you need `double`, write `-> double` and `0` will be converted.\n\nPutting it all together with names:\n\n\n```mermaid\nflowchart LR\n CAP[\"[saleCutoff]
capture list\"]:::cyan --> PAR[\"(double price)
parameters\"]:::orange\n PAR --> RET[\"-> bool
return type
(optional)\"]:::teal\n RET --> BODY[\"{ return price < saleCutoff; }
body\"]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nReading left to right: the capture list pulls names in from outside, the parameter list defines what the lambda receives at each call, the optional trailing return type pins down what comes back, and the body is the actual code that runs. Every lambda you write fits this shape, even if some parts are empty.\n\n---\n\n# What a Lambda Really Is\n\nUnder the hood, a lambda isn't a magic new kind of value. When the compiler sees a lambda expression, it generates a unique, unnamed class type with a member `operator()`. Each lambda you write produces its own type, called its **closure type**. Each time the expression is evaluated, it constructs an object of that type, called a **closure object**.\n\nSo this code:\n\n\n```cpp\nauto isOnSale = [](double price) { return price < 20.0; };\n```\n\n\nis roughly equivalent to:\n\n\n```cpp\nstruct __SomeUniqueName {\n bool operator()(double price) const {\n return price < 20.0;\n }\n};\n\n__SomeUniqueName isOnSale;\n```\n\n\nThe exact generated name is up to the compiler and isn't visible to your code. What matters is the consequence: every lambda has its own distinct type, even if two lambdas look identical.\n\n\n```cpp\nauto a = [](int x) { return x * 2; };\nauto b = [](int x) { return x * 2; };\n// decltype(a) and decltype(b) are different types\n```\n\n\nThis is why you store lambdas in `auto` variables almost always. There's no way to write the type by hand because the type doesn't have a name you can write.\n\nThe closure type has `operator()` defined the way you'd expect, taking the parameter list you wrote, returning what the body returns. For a non-capturing lambda, the closure type has no member variables, so its objects are essentially stateless. Capturing lambdas store their captured values as member variables of the closure type, which is the next chapter's topic.\n\nOne more thing about the closure type: by default, `operator()` is `const`. The body can read captured values but not modify them. The `mutable` keyword lifts that restriction.\n\n\n```mermaid\nflowchart LR\n SRC[\"auto cmp =
[](int a, int b)
{ return a < b; };\"]:::cyan --> GEN[\"compiler generates
unique closure type\"]:::orange\n GEN --> CLS[\"struct __Lambda_xyz {
bool operator()
(int a, int b) const
{ return a < b; }
};\"]:::teal\n CLS --> OBJ[\"cmp is an object
of __Lambda_xyz\"]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThe diagram walks through what happens when the compiler sees a lambda. It generates a private class with a single `operator()` whose signature matches the lambda's parameter list, then the lambda expression itself is just an object of that class. There's no runtime magic, no hidden vtable, no extra indirection. Calling `cmp(1, 2)` is a direct call to `__Lambda_xyz::operator()(1, 2)`.\n\n---\n\n# Captures, Briefly\n\nCaptures deserve their own chapter, and they get one later. But you need at least a working idea of them to follow the rest of this chapter, because real lambdas almost always need to see at least one variable from the enclosing scope.\n\nTwo basic capture forms cover most cases:\n\n**Capture by value:** `[name]` makes a copy of `name` into the closure object. The copy is independent of the outside variable from that point on.\n\n\n```cpp\n#include \n\nint main() {\n double cutoff = 20.0;\n auto isUnderCutoff = [cutoff](double price) {\n return price < cutoff;\n };\n cutoff = 100.0; // doesn't affect the lambda's copy\n std::cout << std::boolalpha;\n std::cout << isUnderCutoff(15.0) << std::endl;\n std::cout << isUnderCutoff(50.0) << std::endl;\n return 0;\n}\n```\n\n\nThe lambda captured `cutoff` as `20.0`. Even though `cutoff` was later reassigned to `100.0`, the lambda still uses its own copy of `20.0`. Capture by value freezes the value at the moment the lambda expression runs.\n\n**Capture by reference:** `[&name]` stores a reference to `name`, not a copy. Changes to the outside variable are visible inside the lambda, and changes the lambda makes (if it's `mutable` or if `name` itself isn't const) are visible outside.\n\n\n```cpp\n#include \n\nint main() {\n int orderCount = 0;\n auto recordOrder = [&orderCount]() {\n orderCount += 1;\n };\n recordOrder();\n recordOrder();\n recordOrder();\n std::cout << \"Orders placed: \" << orderCount << std::endl;\n return 0;\n}\n```\n\n\nThe lambda holds a reference to `orderCount` and increments the actual variable in `main`. After three calls, `orderCount` is `3`.\n\nThat's all we'll say here. The rest, capturing multiple variables, default captures (`[=]` and `[&]`), `this`, `mutable`, init captures, generic lambdas, lives in the Lambda Captures & Generic Lambdas lesson. The takeaway for now: `[var]` is by value, `[&var]` is by reference, and lambdas have full access to whatever they capture.\n\n\n> **INFO**\n>\n> **Cost:** Capture by value copies the variable into the closure object. For a `std::string` or a large struct, that's a real allocation or memory copy at the point the lambda is constructed. Capture by reference is free at construction time but creates a lifetime dependency: the lambda must not outlive what it references.\n\n\n---\n\n# Non-Capturing Lambdas Convert to Function Pointers\n\nA lambda with an empty capture list (no `[name]`, no `[&]`, no `[=]`, just `[]`) has a special property: it implicitly converts to a plain function pointer of matching signature. This is convenient when interoperating with C APIs or older C++ code that takes function pointers.\n\n\n```cpp\n#include \n\nusing PriceFn = double(*)(double);\n\ndouble withSalesTax(double price) { return price * 1.08; }\n\nint main() {\n PriceFn applyTax = withSalesTax;\n std::cout << applyTax(100.0) << std::endl; // 108\n\n // Non-capturing lambda assigned to a function pointer:\n PriceFn applyShipping = [](double price) { return price + 5.0; };\n std::cout << applyShipping(100.0) << std::endl; // 105\n\n return 0;\n}\n```\n\n\nThe lambda is converted to a plain function pointer because it has no state to carry. The closure type is empty, so the compiler can produce a regular function with the same signature and hand back a pointer to it.\n\nThis conversion only works for non-capturing lambdas. A lambda that captures anything by value or by reference has state inside the closure object, and a plain function pointer can't carry state. Try it and the compiler refuses:\n\n**What's wrong with this code?**\n\n\n```cpp\ndouble discount = 0.10;\ndouble (*applyDiscount)(double) = [discount](double price) {\n return price * (1.0 - discount);\n};\n```\n\n\nThe lambda captures `discount`, so the closure type has a member variable. A function pointer is just an address; it has nowhere to store `discount`. The compiler reports something like:\n\n\n```shell\nerror: cannot convert '' to 'double (*)(double)' in initialization\n```\n\n\nThe fix is either to drop the capture (and pass `discount` as a parameter) or to store the lambda in something that can hold state, like `auto` or `std::function`. We get to those in a moment.\n\n---\n\n# Lambdas with Standard Algorithms\n\nThe standard library was designed around callable objects, and lambdas are now the everyday way to hand behavior to algorithms. The pattern is almost always: pick an algorithm from ``, pass a range (`begin`, `end`), and pass a lambda that says what to do.\n\n### `std::sort` with a custom comparator\n\nA bookstore lists books with a title and a rating. To sort by rating from highest to lowest:\n\n\n```cpp\n#include \n#include \n#include \n#include \n\nstruct Book {\n std::string title;\n double rating;\n};\n\nint main() {\n std::vector books = {\n {\"The Pragmatic Programmer\", 4.6},\n {\"Clean Code\", 4.4},\n {\"Effective C++\", 4.7},\n {\"The C++ Programming Language\", 4.2}\n };\n\n std::sort(books.begin(), books.end(), [](const Book& a, const Book& b) {\n return a.rating > b.rating;\n });\n\n for (const Book& b : books) {\n std::cout << b.rating << \" \" << b.title << std::endl;\n }\n return 0;\n}\n```\n\n\nThe comparator returns `true` when the first argument should come before the second. For descending order by rating, that means \"`a` comes first if its rating is greater than `b`'s\". The lambda is the one piece of code that's specific to \"sort books by rating descending\", and it lives right at the call site.\n\n\n> **INFO**\n>\n> **Cost:** `std::sort` is O(n log n) and typically uses introsort under the hood (quicksort with a heap-sort fallback). The comparator runs O(n log n) times, so an expensive comparator dominates the cost. Keep comparator lambdas cheap and avoid recomputing values inside them.\n\n\n### `std::for_each` to apply a side effect\n\n`std::for_each` runs a callable on every element of a range. It's most useful when the action has a side effect, like printing, logging, or updating an external counter.\n\n\n```cpp\n#include \n#include \n#include \n\nint main() {\n std::vector cartPrices = {12.50, 4.99, 8.00, 22.99, 3.25};\n double total = 0.0;\n\n std::for_each(cartPrices.begin(), cartPrices.end(), [&total](double price) {\n total += price;\n });\n\n std::cout << \"Cart total: $\" << total << std::endl;\n return 0;\n}\n```\n\n\nThe lambda captures `total` by reference and adds each price to it. By the end of the call, `total` holds the sum. You could also use `std::accumulate` for sums specifically, but `for_each` works for any side effect, not just accumulation.\n\nIn modern code, a range-based `for` loop is often clearer than `std::for_each` for the same task. The algorithm version shines when you're composing it with other algorithms or when you want to make the iteration explicit at the type level.\n\n### `std::find_if` to locate the first match\n\n`std::find_if` walks the range and returns an iterator to the first element for which the lambda returns `true`. If nothing matches, it returns `end()`.\n\n\n```cpp\n#include \n#include \n#include \n#include \n\nstruct Product {\n std::string name;\n double price;\n int stock;\n};\n\nint main() {\n std::vector catalog = {\n {\"Wireless Mouse\", 24.99, 0},\n {\"Mechanical Keyboard\", 89.50, 12},\n {\"Monitor Stand\", 39.00, 4},\n {\"USB Hub\", 18.75, 0}\n };\n\n auto firstInStock = std::find_if(catalog.begin(), catalog.end(),\n [](const Product& p) {\n return p.stock > 0;\n });\n\n if (firstInStock != catalog.end()) {\n std::cout << \"First available: \" << firstInStock->name\n << \" ($\" << firstInStock->price << \")\" << std::endl;\n } else {\n std::cout << \"Nothing in stock\" << std::endl;\n }\n return 0;\n}\n```\n\n\nThe lambda is a predicate: it takes one argument and returns `bool`. `find_if` is one of a family that includes `std::any_of`, `std::all_of`, `std::none_of`, `std::count_if`, and `std::remove_if`. All of them take the same kind of predicate lambda.\n\n### Combining algorithms with capturing predicates\n\nA capturing lambda gives you a parametrized predicate, which is where the pattern really earns its keep. To find the first product under a threshold price:\n\n\n```cpp\n#include \n#include \n#include \n#include \n\nstruct Product {\n std::string name;\n double price;\n};\n\nint main() {\n std::vector catalog = {\n {\"Wireless Mouse\", 24.99},\n {\"Mechanical Keyboard\", 89.50},\n {\"Monitor Stand\", 39.00},\n {\"USB Hub\", 18.75}\n };\n\n double budget = 20.0;\n auto firstAffordable = std::find_if(catalog.begin(), catalog.end(),\n [budget](const Product& p) {\n return p.price <= budget;\n });\n\n if (firstAffordable != catalog.end()) {\n std::cout << \"Under $\" << budget << \": \" << firstAffordable->name\n << \" ($\" << firstAffordable->price << \")\" << std::endl;\n }\n return 0;\n}\n```\n\n\n`budget` is captured by value, so the lambda carries its own copy of `20.0`. Change `budget` to a different number, recreate the lambda, get a different predicate. This is the lambda pattern that's hardest to replicate cleanly with a free function: a free function has nowhere to put `budget`, so you'd have to pass it as an extra parameter (which doesn't fit `find_if`'s expected signature) or fall back to a functor with a constructor.\n\n---\n\n# Storing Lambdas: `auto` vs `std::function`\n\nOnce you have a lambda, you have to decide where to put it. There are three main options.\n\n### Pass it inline\n\nThe simplest case: don't store the lambda at all, pass it directly into the function that needs it. This is what every `std::sort` example so far has done.\n\n\n```cpp\nstd::sort(orders.begin(), orders.end(),\n [](const Order& a, const Order& b) { return a.total > b.total; });\n```\n\n\nNo variable, no type name, no storage decision. If the lambda is used once and never named, inline is the right answer.\n\n### Store it in `auto`\n\nIf you need to use the lambda more than once, give it a name with `auto`:\n\n\n```cpp\nauto byTotalDescending = [](const Order& a, const Order& b) {\n return a.total > b.total;\n};\n\nstd::sort(activeOrders.begin(), activeOrders.end(), byTotalDescending);\nstd::sort(archivedOrders.begin(), archivedOrders.end(), byTotalDescending);\n```\n\n\nThe variable has the lambda's actual closure type, which means the compiler knows exactly what's being called. It can inline the body at every call site, which makes the call as cheap as if you'd written a regular function call. There's no runtime indirection, no type erasure, no allocation.\n\nThe downside is that you can't write the type by hand. The closure type has no name you can spell. So if you want to store the lambda as a class member, or in a `std::vector`, or return it from a function, `auto` (or `decltype`) only takes you so far. Member variables can't be declared `auto` (until C++17 with `auto` non-type template parameters and other narrow cases that don't apply here). Vectors need a single concrete element type, but each lambda has its own type. Return values can use `auto` since C++14, which is fine.\n\n### Store it in `std::function`\n\n`std::function` from `` is a type-erased wrapper. It can hold any callable with the matching signature: a function pointer, a lambda, a functor, a `std::bind` result, the lot. The price is that calling through a `std::function` has runtime overhead, and constructing one from a stateful lambda may allocate.\n\n\n```cpp\n#include \n#include \n#include \n\nint main() {\n using Discount = std::function;\n\n std::vector activePromos;\n activePromos.push_back([](double p) { return p * 0.90; }); // 10% off\n activePromos.push_back([](double p) { return p - 5.0; }); // $5 off\n activePromos.push_back([](double p) { return p < 50.0 ? p : 50.0; });// price cap at $50\n\n double price = 60.0;\n for (const Discount& promo : activePromos) {\n std::cout << \"Discounted: $\" << promo(price) << std::endl;\n }\n return 0;\n}\n```\n\n\nEach lambda has its own closure type. They're all incompatible with each other and can't share an `auto` slot. `std::function` is a single type that erases their differences, so all three fit in one vector.\n\nThe cost is real. A `std::function` call typically goes through a virtual dispatch or a function-pointer indirection internally, which the compiler can't inline. For a lambda small enough to fit in `std::function`'s small-buffer optimization (usually around 16-32 bytes, implementation-defined), there's no heap allocation, just an internal copy. For larger lambdas (lots of captures, large captured types), `std::function` allocates on the heap to store the closure.\n\n\n> **INFO**\n>\n> **Cost:** `std::function` calls are typically 5-20 nanoseconds slower than a direct call, because the compiler can't inline through the type-erased wrapper. Construction may allocate. Use it when you need polymorphism over callables. Use `auto` (or a template) when you can.\n\n\n### When to pick which\n\n\n| Use case | Prefer | Why |\n|----------|--------|-----|\n| One-off comparator/predicate passed to an algorithm | Inline lambda | No naming overhead, easiest to read |\n| Lambda used at multiple call sites in one scope | `auto` | Zero runtime cost, compiler inlines |\n| Storing lambdas in a container (vector, map) | `std::function` | Different lambdas have different types; need erasure |\n| Class member that holds a callback | `std::function` | Members can't be `auto`; need a writable type |\n| Function parameter for a callable | Template (`template`) | Zero cost, accepts any callable |\n| Function parameter when you need a uniform type | `std::function` | Type erasure at the parameter |\n\n\nThe default is `auto`. Reach for `std::function` only when you have to, usually because you need a concrete, writable type for storage or for a class member.\n\n---\n\n# A Worked Example: Filter, Sort, Discount\n\nPulling the pieces together: an online store wants to list all in-stock products under a budget, sorted from cheapest to most expensive, with a 10% discount applied. Three lambdas, three algorithms.\n\n\n```cpp\n#include \n#include \n#include \n#include \n#include \n\nstruct Product {\n std::string name;\n double price;\n int stock;\n};\n\nint main() {\n std::vector catalog = {\n {\"Wireless Mouse\", 24.99, 7},\n {\"Mechanical Keyboard\", 89.50, 12},\n {\"Monitor Stand\", 39.00, 0},\n {\"USB Hub\", 18.75, 3},\n {\"Webcam\", 49.99, 5},\n {\"Desk Lamp\", 32.00, 0}\n };\n\n double budget = 50.0;\n\n // Predicate captures budget by value.\n auto inStockAndAffordable = [budget](const Product& p) {\n return p.stock > 0 && p.price <= budget;\n };\n\n // Comparator has no state.\n auto byPriceAscending = [](const Product& a, const Product& b) {\n return a.price < b.price;\n };\n\n // Discount stored as std::function so it can be swapped at runtime.\n std::function discount = [](double price) {\n return price * 0.90;\n };\n\n std::vector matches;\n std::copy_if(catalog.begin(), catalog.end(),\n std::back_inserter(matches),\n inStockAndAffordable);\n std::sort(matches.begin(), matches.end(), byPriceAscending);\n\n for (const Product& p : matches) {\n std::cout << p.name\n << \" list: $\" << p.price\n << \" sale: $\" << discount(p.price) << std::endl;\n }\n return 0;\n}\n```\n\n\nThree different storage choices in one program. The predicate is `auto` because it's used once but benefits from being named for clarity. The comparator is `auto` because it has no state. The discount is `std::function` because a real store would swap it for a different rule (a $5-off lambda, a holiday-only lambda) at runtime, and the storage has to accept any of them.\n\n`std::copy_if` walks the catalog and copies every product matching the predicate into `matches`. `std::sort` puts them in ascending price order. The final loop applies the discount through the `std::function` wrapper. All three callables are lambdas, all three live at the call site or one line above it.\n\n\n```mermaid\nflowchart LR\n CAT[Catalog
6 products]:::cyan --> FIL[copy_if
predicate lambda]:::orange\n FIL --> MAT[Matches
3 products]:::green\n MAT --> SRT[sort
comparator lambda]:::orange\n SRT --> SORTED[Sorted by price]:::green\n SORTED --> APP[for each
discount lambda]:::orange\n APP --> OUT[Final output]:::teal\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThe diagram shows the data flowing through three algorithm calls, each with its own lambda. The catalog (cyan) enters, the predicate lambda inside `copy_if` (orange) filters it down to a smaller list of matches (green), the comparator lambda inside `sort` reorders them, and the discount lambda inside the print loop transforms each price for display. This is the everyday shape of code that uses the standard library: data plus a pipeline of algorithms, each parametrized by a small lambda.\n\n---\n\n# Summary\n\n- A lambda expression is an inline, unnamed callable with the form `[capture](params) -> return_type { body }`. The capture list and body are required syntax; the parameter list and trailing return type are required only when you need them.\n- The compiler generates a unique, unnamed class (the closure type) for each lambda. Each invocation of the expression produces a closure object of that type with `operator()` matching the lambda's signature.\n- Return type is deduced from the body in most cases. Write `-> T` only when the body has mixed return types or when you want to force a different return type than the deduction would pick.\n- Non-capturing lambdas (empty `[]`) implicitly convert to a plain function pointer. Any capture, even a single one, kills that conversion because the closure object now has state to carry.\n- Lambdas pair naturally with `` functions: `std::sort` with a comparator, `std::for_each` with a side effect, `std::find_if`/`count_if`/`any_of`/`all_of` with a predicate.\n- Store lambdas in `auto` when you can; the compiler knows the exact type, can inline calls, and adds no runtime overhead. Use `std::function` only when you need a uniform, writable type (class member, container element, function parameter that accepts any callable), and accept the call-time and possible allocation cost.\n- Captures are the bridge between a lambda's body and the enclosing scope. By value (`[x]`) copies, by reference (`[&x]`) aliases. We showed the basics here only as context.\n\nThe next chapter takes captures apart in detail: capturing multiple variables, default captures `[=]` and `[&]`, init captures (`[name = expr]`), `mutable` lambdas, capturing `this`, and the lifetime traps that turn capture-by-reference into dangling references when you aren't careful.","pageType":"cpp"}

Lambda Expressions (C++11)

Get Premium