Show lambda with parameters are used? How to pass parameters to them?

It works exactly like with any other type of callable object:

#include <iostream>

int main()
{
    auto l = [] (int i) { std::cout << "The answer is " << i; };
    l(42);
}

Also notice, that you do not need to store a lambda in a variable in order to invoke it. The following is an alternative way to rewrite the above program:

#include <iostream>

int main()
{
    [] (int i) { std::cout << "The answer is " << i; } (42);
    //                                                 ^^^^
    //                                 Invoked immediately!
}

The type of a lambda function (the so-called "lambda closure") is defined by the compiler, and is a functor with a call operator whose signature is the one you specify when defining the lambda. Therefore, you call a lambda exactly as you would call a functor (i.e. exactly as you would call a function - or any callable object).

Thus, if you want to assign a lambda to an object, the best practice is to let the compiler deduce its type by using auto. If you do not want or cannot use auto, then you may:

1. Use function pointers for non-capturing lambdas (capturing lambdas are not convertible to function pointers). In the above case, thus, the following will also work:

   #include <iostream>
   
   int main()
   {
       void (*f)(int) = [] (int i) { std::cout << "The answer is " << i; };
       f(42);
   }
   

2. Use std::function (this is always possible, even if the lambda is capturing):

   #include <iostream>
   #include <functional>
   
   int main()
   {
       std::function<void(int)> f = [] (int i) 
                                  { std::cout << "The answer is " << i; };
       f(42);
   }
   

You have 2 ways: make your function template:

template <typename F>
void myFunction(F&& lambda)
{
    //some things
}

or erase type (with std::function for example):

void
myFunction(const std::function<void()/*type of your lamdba::operator()*/>& f)
{
    //some things
}

You cannot have an auto parameter. You basically have two options:

Option #1: Use std::function as you have shown.

Option #2: Use a template parameter:

template<typename F>
void f(F && lambda) { /* ... */}

Option #2 may, in some cases, be more efficient, as it can avoid a potential heap allocation for the embedded lambda function object, but is only possible if f can be placed in a header as a template function. It may also increase compile times and I-cache footprint, as can any template. Note that it may have no effect as well, as if the lambda function object is small enough it may be represented inline in the std::function object.

Don't forget to use std::forward<F&&>(lambda) when referring to lambda, as it is an r-value reference.