Passing lambdas with different signatures to generic function - c++

Question

Considering the following toy example:
#include <iostream>
template <typename T>
void foo(T func, int *i) {
if (i) {
func(*i);
} else {
func();
}
}
int main() {
auto n = new int{2};
foo([](int x) { std::cout << x << std::endl; }, n);
foo([]() { std::cout << "Foo" << std::endl; }, nullptr);
return 0;
}
I want to create a function which receives lambdas functions with different signatures and call them inside its scope. If I do not call the lambda function inside foo, it compiles fine, but if I call it, the code does not compile.
Is there any way of receiving lambdas with different signatures and call it in a function?

Answer 1

Inside your function template, T has to be determined as one specific type, and remains that type throughout the entirety of that instantiation.
You can, however, accomplish what you want by making foo a variadic template, and passing the parameter pack through to the lambda that was passed in:
#include <iostream>
template <typename T, typename ...Args>
void foo(T func, Args... args) {
func(std::forward<Args>(args)...);
}
int main() {
auto n = new int{ 2 };
foo([](int x) { std::cout << x << std::endl; }, n[0]);
foo([]() { std::cout << "Foo" << std::endl; });
foo([](int a, int b) { std::cout << a + b << "\n"; }, 3, 2);
}
This way foo only needs to contain one invocation of func, which has a consistent type throughout each instantiation--but can vary from one instantiation to the next.
In this case, when the function you're passing doesn't take any arguments, you don't pass a special value for the argument. If it doesn't take an argument, you just don't pass an argument.

Answer 2

In the first case where you instantiate the template function with:
foo([](int x) { std::cout << x << std::endl; }, n);
The compiler creates the function where (T func) is a callable taking an int as function, therefore you can't do:
void foo(T func, int *i) {
if (i) {
func(*i);
}
//else
//{
// func(); // Can't call T func with no argument.
//} // Commenting this out will compile.
}
When you instantiate the template function with:
foo([]() { std::cout << "Foo" << std::endl; }, nullptr);
The compiler creates the function:
void foo(T func, int *i); // Where T func is a callable taking no arguments
So, in contrast to the previous example, you must must call T func with no arguments given. Therefore you can't do:
template <typename T>
void foo(T func, int *i)
{
//if (i) {
// func(*i); // Can't call T func with one argument, because
// T func function template has been instantiated
// as T func taking no arguments.
//}
//else
{
func(); // This obviously is fine.
}
}