Why do I get "candidate expects 2 arguments, 1 provided" compilation error when forwarding functions with C++11?

I'm trying to understand function forwarding with lambdas on C++ by running this code:

#include <functional>

template<typename Func, typename... Args>
int do_something_1(int foo_1, Func&& func, Args&&... args, int foo_0 = 0) { 
    int var_1 = foo_0 + 2 * foo_1; 
    return std::forward<Func>(func)(var_1, std::forward<Args>(args)...);
};

int main (void) {
    return do_something_1(1, [](int var_1, int local_var) { return (var_1 + local_var); }, 4);
}

However it fails with this compilation error:

<source>: In instantiation of 'int do_something_1(int, Func&&, Args&& ..., int) [with Func = main()::<lambda(int, int)>; Args = {}]':
<source>:11:93:   required from here
<source>:7:36: error: no match for call to '(main()::<lambda(int, int)>) (int&)'
    7 |     return std::forward<Func>(func)(var_1, std::forward<Args>(args)...);
      |            ~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<source>:7:36: note: candidate: 'int (*)(int, int)' (conversion)
<source>:7:36: note:   candidate expects 3 arguments, 2 provided
<source>:11:30: note: candidate: 'main()::<lambda(int, int)>'
   11 |     return do_something_1(1, [](int var_1, int local_var) { return (var_1 + local_var); }, 4);
      |                              ^
<source>:11:30: note:   candidate expects 2 arguments, 1 provided

And I don't know how to correct it.

This has nothing to do with forwarding. Its just making the error more difficult to spot.

You are calling

template<typename Func, typename... Args>
int do_something_1(int foo_1, Func&& func, Args&&... args, int foo_0 = 0)

via

do_something_1(1, ...lambda..., 4);

ie, foo_1 is 1, foo_0 is 4 and sizeof...(args)==0.

Not sure what you wanted to pass to the lambda. However, the issue is that you pass only 1 when 2 arguments are expected.

Non-terminal function parameter packs are a "non-deduced context" ([temp.deduct.type]/5):
> The non-deduced contexts are:
> - [...]
> - A function parameter pack that does not occur at the end of the parameter-declaration-list.

This means that the 4 which you pass as an argument will not be used to deduce Args, but is instead bound to foo_0.

Technically you can make this compile by providing template arguments explicitly:

int main (void) {
    return do_something_1<int(*)(int,int), int>(1, [](int var_1, int local_var) { return (var_1 + local_var); }, 4);
}

This works because the non-capturing lambda can convert to a function pointer, and explicitly supplying int as a second template argument causes the 4 to bind to args... instead of foo_0.

But in general I'd recommend avoiding non-terminal function parameter packs when possible.