自C++11%29以来LAMBDA表达式%28

 params   -   The list of parameters, as in [named functions](function), except that [default arguments](default_arguments) are not allowed (until C++14). If `auto` is used as a type of a parameter, the lambda is a _generic lambda_. (since C++14)     ret   -   Return type. If not present it's implied by the function return statements (or void if it doesn't return any value)     body   -   Function body   

struct X {
    int x, y;
    int operator()(int
    void f()
    {
        // the context of the following lambda is the member function X::f
        [=]()->int
        {
            return operator()(this->x + y // X::operator()(this->x + (*this).y)
                                            // this has type X*
        };
    }
};

struct S2 { void f(int i };
void S2::f(int i)
{
    [&]{}; //ok: by-reference capture default
    [=]{}; //ok: by-copy capture default
    [&, i]{}; // ok: by-reference capture, except i is captured by copy
    [=, &i]{}; // ok: by-copy capture, except i is captured by reference
    [&, &i] {}; // error: by-reference capture when by-reference is the default
    [=, this] {}; // error: this when = is the default
    [=, *this]{}; // ok: captures the enclosing S2 by copy (C++17)
    [i, i] {}; // error: i repeated
    [this, *this] {}; // error: "this" repeated (C++17)
}

void f(const int*
void g()
{
    const int N = 10;
    [=]{ 
        int arr[N]; // not an odr-use: refers to g's const int N
        f(&N // odr-use: causes N to be captured (by copy)
               // &N is the address of the closure object's member N, not g's N
    }(
}

#include <iostream>
 
auto make_function(int& x) {
  return [&]{ std::cout << x << '\n'; };
}
 
int main() {
  int i = 3;
  auto f = make_function(i // the use of x in f binds directly to i
  i = 5;
  f( // OK; prints 5
}

void f3() {
    float x, &r = x;
    [=]
    { // x and r are not captured (appearance in a decltype operand is not an odr-use)
        decltype(x) y1; // y1 has type float
        decltype((x)) y2 = y1; // y2 has type float const& because this lambda
                               // is not mutable and x is an lvalue
        decltype(r) r1 = y1;   // r1 has type float& (transformation not considered)
        decltype((r)) r2 = y2; // r2 has type float const&
    };
}

struct s2 {
  double ohseven = .007;
  auto f() { // nearest enclosing function for the following two lambdas
    return [this] { // capture the enclosing s2 by reference
      return [*this] { // capture the enclosing s2 by copy (C++17)
          return ohseven; // OK
       }
     }(
  }
  auto g() {
     return []{ // capture nothing
         return [*this]{}; // error: *this not captured by outer lambda-expression
      }(
   }
};

void f1(int i)
{
    int const N = 20;
    auto m1 = [=] {
            int const M = 30;
            auto m2 = [i] {
                    int x[N][M]; // N and M are not odr-used 
                                 // (ok that they are not captured)
                    x[0][0] = i; // i is explicitly captured by m2
                                 // and implicitly captured by m1
            };
    };
 
    struct s1 // local class within f1()
    {
        int f;
        void work(int n) // non-static member function
        {
            int m = n * n;
            int j = 40;
            auto m3 = [this, m] {
                auto m4 = [&, j] { // error: j is not captured by m3
                        int x = n; // error: n is implicitly captured by m4
                                   // but not captured by m3
                        x += m;    // ok: m is implicitly captured by m4
                                   // and explicitly captured by m3
                        x += i;    // error: i is outside of the reaching scope
                                   // (which ends at work())
                        x += f;    // ok: this is captured implicitly by m4
                                   // and explicitly captured by m3
                };
            };
        }
    };
}

class S {
  int x = 0;
  void f() {
    int i = 0;
//  auto l1 = [i, x]{ use(i, x };    // error: x is not a variable
    auto l2 = [i, x=x]{ use(i, x };  // OK, copy capture
    i = 1; x = 1; l2( // calls use(0,0)
    auto l3 = [i, &x=x]{ use(i, x }; // OK, reference capture
    i = 2; x = 2; l3( // calls use(1,2)
  }
};

class S {
  int x = 0;
  void f() {
    int i = 0;
    auto l1 = [=]{ use(i, x }; // captures a copy of i and a copy of the this pointer
    i = 1; x = 1; l1( // calls use(0,1), as if i by copy and x by reference
    auto l2 = [i, this]{ use(i, x }; // same as above, made explicit
    i = 2; x = 2; l2( // calls use(1,2), as if i by copy and x by reference
    auto l3 = [&]{ use(i, x }; // captures i by reference and a copy of the this pointer
    i = 3; x = 2; l3( // calls use(3,2), as if i and x are both by reference
    auto l4 = [i, *this]{ use(i, x }; // makes a copy of *this, including a copy of x
    i = 4; x = 4; l4( // calls use(3,2), as if i and x are both by copy
  }
};

#include <iostream>
 
int main()
{
    int a = 1, b = 1, c = 1;
 
    auto m1 = [a, &b, &c]() mutable {
        auto m2 = [a, b, &c]() mutable {
            std::cout << a << b << c << '\n';
            a = 4; b = 4; c = 4;
        };
        a = 3; b = 3; c = 3;
        m2(
    };
 
    a = 2; b = 2; c = 2;
 
    m1(                             // calls m2() and prints 123
    std::cout << a << b << c << '\n'; // prints 234
}

#include <vector>
#include <iostream>
#include <algorithm>
#include <functional>
 
int main()
{
    std::vector<int> c = {1, 2, 3, 4, 5, 6, 7};
    int x = 5;
    c.erase(std::remove_if(c.begin(), c.end(), [x](int n) { return n < x; }), c.end()
 
    std::cout << "c: ";
    std::for_each(c.begin(), c.end(), [](int i){ std::cout << i << ' '; }
    std::cout << '\n';
 
    // the type of a closure cannot be named, but can be inferred with auto
    auto func1 = [](int i) { return i + 4; };
    std::cout << "func1: " << func1(6) << '\n';
 
    // like all callable objects, closures can be captured in std::function
    // (this may incur unnecessary overhead)
    std::function<int(int)> func2 = [](int i) { return i + 4; };
    std::cout << "func2: " << func2(6) << '\n';
}

c: 5 6 7
func1: 10
func2: 10

 © cppreference.com