The square brackets are the capture clause; the parentheses are the parameter list; the braces are the body. The compiler synthesises a closure type with operator(), so the lambda is callable like any function object. auto add = [](int, int) { ... }; stores it in a variable; passing it inline to algorithms is more common. The return type is deduced; you can specify it explicitly with -> int after the parameter list when deduction would be ambiguous.

[=] snapshots every variable used in the body at lambda creation time; the lambda is independent of subsequent changes to the outer variables. [&] does the opposite: every used name is bound by reference, so the lambda sees the current value at call time. Pin captures down explicitly ([multiplier] or [&counter]) for non-trivial lambdas; the catch-all forms make it easy to accidentally extend the lifetime of a stack reference past the lambda's first call. Always prefer named captures over [=] or [&] in code reviewed by humans.

Standard algorithms accept any callable as a predicate or comparator, and lambdas are the cleanest way to supply one. The comparator for std::sort is bool less(const T& a, const T& b): return true if a should come before b. Predicates for std::count_if, std::any_of, std::find_if follow the same shape with one argument. Pre-C++11 you had to write a free function or a struct with operator(); with lambdas, the predicate sits exactly where it is used, which makes the algorithm call read like a sentence.