Pass auto lambda function to `invoke()`

[brendan-simon-indt]

How can I pass a C++ lambda function to invoke() as a mock implementation of the function foo()?

I want something like this in my test.

    //! lambda function to implement mocked alternative function
    auto mock_foo = [](bar_t *bar, int len)
    {
        bar->a = 10;
        bar->b = 11;
        bar->x = len;
    };
    MOCKER(foo).stubs().will(invoke(mock_foo));

I couldn't get that to work with auto, but it does work if explicitly declare a function pointer (but it's more unnecessary boiler plate)

    //! lambda function to implement mocked alternative function
    void (*mock_foo)(bar_t *bar, int len) = [](bar_t *bar, int len)
    {
        bar->a = 10;
        bar->b = 11;
        bar->x = len;
    };
    MOCKER(foo).stubs().will(invoke(mock_foo));

How can I avoid the unnecessary boiler plate and use auto with my lamda function?
I should also be able to use an anonymous lambda function directly in invoke().

    //! lambda function to implement mocked alternative function
    MOCKER(foo).stubs().will(invoke(
      [](bar_t *bar, int len)
          {
              bar->a = 10;
              bar->b = 11;
              bar->x = len;
          };
    ));

[brendan-simon-indt]

A small improvement in readability is to use typedef for the function signature.

    //! lambda function to implement mocked alternative function
    typedef void foo_f(bar_t *bar, int len);
    foo_f *mock_foo = [](bar_t *bar, int len)
    {
        bar->a = 10;
        bar->b = 11;
        bar->x = len;
    };
    MOCKER(foo).stubs().will(invoke(mock_foo)));

or

    //! lambda function to implement mocked alternative function
    typedef void foo_f(bar_t *bar, int len);
    MOCKER(foo).stubs().will(invoke(
      (foo_f*)[](bar_t *bar, int len)
          {
              bar->a = 10;
              bar->b = 11;
              bar->x = len;
          };
    ));

[brendan-simon-indt]

Using lambda functions was workaround for C/C++ not supporting nested functions.
A google search showed another workaround, which is a little cleaner, to put declare a static function inside a struct.

    //! mock implementation of `foo()` function
    //! uses static public function inside C++ struct as C/C++ does not support true nested functions.
    struct F { static void foo(bar_t *bar, int len)
    {
        bar->a = 10;
        bar->b = 11;
        bar->x = len;
    }; };
    MOCKER(foo).stubs().will(invoke(F::foo));

Given the above, my need for better support of auto and lambdas is diminished, but still it would be "nice" :)

[wujimin]

MOCKER(foo).stubs().will(invoke(+[]()bar_t *bar, int len) {})
notice: the +

[brendan-simon-indt]

Fantastic !!
I can't find any info on the leading + for lambdas (wow, lambdas can be complex).
What does the leading + do?

[wujimin]

Fantastic !! I can't find any info on the leading + for lambdas (wow, lambdas can be complex). What does the leading + do?

i forgot why i knew this.
and i ask AI，google it，but can not find the specifications......

[arong]

https://stackoverflow.com/questions/18889028/a-positive-lambda-what-sorcery-is-this :

When operator + is applied to the closure object, the set of overloaded built-in candidates contains a conversion-to-any-pointer and the closure type contains exactly one candidate: The conversion to the function pointer of the lambda.

@wujimin @brendan-simon-indt