{"title":"Lambda Expressions (C++11)","description":null,"content":"A lambda expression is a callable object defined inline where it's needed, 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 is, the parts of its syntax, how to use it with the standard library, and where to store one. Captures get a brief mention here for context; the deep dive on them lives in the next chapter.\n\n---\n\n# Why Lambdas Exist\n\nBefore lambdas, handing a small piece of behavior to a standard algorithm or a thread had two options, both unwieldy.\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\nThe free function works correctly. Floating-point output doesn't show trailing zeros by default, so the actual run prints `129, 49.99, 14.5, 7.25`. The free function does its job.\n\nThe downside is that `byTotalDescending` lives far away from the call site. Understanding what `std::sort` is doing requires jumping 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. 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()`, but it isn't written manually.\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.\n\n\n```cpp\nauto doNothing = [](){};\ndoNothing(); // does, indeed, nothing\n```\n\n\nEach part means a specific thing. A running example walks through them.\n\n### The capture list `[ ]`\n\nThe capture list is the only part 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. Captures are covered in a few sections. For now, they are \"names from outside that the body uses\".\n\n### The parameter list `( )`\n\nParameters work like function parameters. Types, references, defaults, all of them.\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\nFor a lambda with no parameters, C++23 allows dropping the parentheses entirely. 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\nThe parentheses appear explicitly in this course so the examples compile with `-std=c++17`.\n\n### The body `{ }`\n\nThe body is 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 piece most lambdas leave off. C++ deduces the return type from the body in almost every realistic case. The `-> T` syntax is needed only 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 to write a return type for a lambda. It can't go before the `[` the way it would 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 produces a long error. With the trailing return type, every return is implicitly converted to `std::string`.\n\nThe other case is forcing a different type than what the body produces, usually a wider type. Returning `0` deduces to `int`; for `double`, `-> double` makes `0` get converted.\n\nThe pieces 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 fits this shape, even when some parts are empty.\n\n---\n\n# What a Lambda Really Is\n\nA lambda isn't a new kind of value. When the compiler sees a lambda expression, it generates a unique, unnamed class type with a member `operator()`. Each lambda 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\nThis 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 user code. 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 lambdas are almost always stored in `auto` variables. The type can't be written by hand because it doesn't have a name.\n\nThe closure type has `operator()` defined as expected, taking the parameter list and 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.\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 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. A working idea of them is needed 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 snapshots 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 this chapter covers about captures. The rest, capturing multiple variables, default captures (`[=]` and `[&]`), `this`, `mutable`, init captures, generic lambdas, lives in the Lambda Captures & Generic Lambdas lesson. The takeaway: `[var]` is by value, `[&var]` is by reference, and lambdas have full access to whatever they capture.\n\nCapture 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# 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 return 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. The compiler refuses:\n\n**Broken 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`. Those are covered next.\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 specific to \"sort books by rating descending\", and it lives right at the call site.\n\n`std::sort` is O(n log n) and typically uses introsort (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### `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. `std::accumulate` also works 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 is useful when composing it with other algorithms or when making 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 provides a parametrized predicate. 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`. Changing `budget` to a different number and recreating the lambda produces 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 it would have to be passed as an extra parameter (which doesn't fit `find_if`'s expected signature) or replaced with a functor that has a constructor.\n\n---\n\n# Storing Lambdas: `auto` vs `std::function`\n\nOnce a lambda is constructed, it needs a place to live. 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. For a lambda used once and never named, inline is the right answer.\n\n### Store it in `auto`\n\nFor a lambda used 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 a regular function call. There's no runtime indirection, no type erasure, no allocation.\n\nThe downside is that the type can't be written by hand. The closure type has no name. So storing the lambda as a class member, in a `std::vector`, or returning it from a function, `auto` (or `decltype`) only takes things 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 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`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 for polymorphism over callables. Use `auto` (or a template) otherwise.\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`. Use `std::function` only when required, usually for 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.","pageType":"cpp"}

Lambda Expressions (C++11)

Get Premium