Lambda

Collaboration diagram for Lambda:

Functions
static void	lambda_basics (void)
static void	lambda_capture (void)
void	container_11 ()
	container More...
void	algorithm_11 ()
	algorithm More...
void	sort_11 ()
	Compare with sort_03. More...

Detailed Description

https://en.cppreference.com/w/cpp/language/lambda https://www.geeksforgeeks.org/lambda-expression-in-c/

Function Documentation

algorithm_11()

void algorithm_11

(

)

algorithm

Definition at line 478 of file 11.cpp.

{
    vector<int> v = {1, 2, 3};
    assert(find(begin(v), end(v), 0) == end(v));
    assert(find(begin(v), end(v), 1) != end(v));
}

Here is the caller graph for this function:

container_11()

void container_11

(

)

container

forward_list

Definition at line 444 of file 11.cpp.

{
    // [list_initialization](https://en.cppreference.com/w/cpp/language/list_initialization)
    vector<int> v = {1, 2, 3};
    assert(v.data()[2] == 3);
 
    v.shrink_to_fit();
 
    v.emplace(v.cbegin(), 0);
    assert(v.front() == 0);
 
    v.emplace_back(4);
    assert(v.back() == 4);
 
    array<int, 1> a1, a2;
    swap(a1, a2);
 
    forward_list<int> fl;
 
    fl.push_front(1);
    assert(fl.front() == 1);
    fl.emplace_front(2);
    assert(fl.front() == 2);
    fl.insert_after(fl.cbegin(), 3);
    assert(fl.front() + 1 == 3);
    assert(fl.front() == 2);
    fl.erase_after(fl.cbefore_begin()); // like fl.pop_front();
    assert(fl.front() == 3);
    fl.pop_front();
}

Here is the caller graph for this function:

lambda_basics()

static void lambda_basics ( void  )

static

Definition at line 350 of file 11.cpp.

{
    auto annotated_named_lambda_expression =  // optional name
        [ ] // capture clause
        ( ) // optional list of arguments
        { }; // body
 
    // Primitive named lambdas are just like closure functions:
    // https://en.wikipedia.org/wiki/Closure_(computer_programming)
 
    // declaration like a function:
    // void closure() { };
    auto closure = [] { };
 
    closure();
 
    // with arguments
    auto pass = [] (int a) { return a; };
    assert(pass(5) == 5);
 
    // lambda captures external value
    int c = 1;
    auto get_i = [=] () { return c; };
    assert(get_i() == 1);
 
    // lambda captures external variable by reference
    // with omitted arguments and return type
    auto inc_get = [&] { return ++c; };
    assert(inc_get() == 2);
    assert(inc_get() == 3);
 
    // annotated expanded empty inline lambda call:
    [ ] // capture
    ( ) // optional list of arguments
    -> void // optional return value
    { } // body
    ( ); // call with arguments
 
    // annotated expanded sample inline lambda call:
    c = // result
    [c] // capture
    (int a) // an argument
    -> int // return value
    { return c + a; } // body
    (1); // call with argument
    assert(c == 4);
 
    // inline lambda which is called in place
    // https://en.wikipedia.org/wiki/Anonymous_function
 
    // assert((1 + 1) == 2);
    assert([](int a) { return a + 1; }(1) == 2);
 
    // Actually calling lambda inline is useless
    // and is provided only for demonstration.
}

Here is the caller graph for this function:

lambda_capture()

static void lambda_capture ( void  )

static

Definition at line 411 of file 11.cpp.

{
    // read only
    int i = 2;
    assert([=]{return i; }() == 2);
 
    // read and write access
    [&](int a){i = a;}(3);
    assert(i == 3);
 
    // explicit r/o and r/w
    int j;
    [i, &j](){ j = i; }();
    assert(j == i);
 
    // r/o by default
    i++;
    [=, &j](){ j = i; }();
    assert(j == i);
 
    // r/w by default
    i++;
    [&, i](){ j = i; }();
    assert(j == i);
 
    // can access globals anyway
    auto inc_global = [] () { return ++glob; };
    assert(inc_global() == 1);
    assert(inc_global() == 2);
}

Here is the caller graph for this function:

sort_11()

void sort_11

(

)

Compare with sort_03.

array

Definition at line 487 of file 11.cpp.

{
 
    array<int, 10> s {5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
    sort(s.begin(), s.end(),
          // sort using a lambda expression
          [](int a, int b)
          { return a > b; }
         );
}

Here is the caller graph for this function: