I want to be able to wrap a function call with some arbitrary 'prefix' and 'postfix' code, like so:
template <typename Function, typename ... Args>
void WrappedCall(Function f, Args ... args)
{
//Do something before the call...
f(args...);
//Do something after the call...
}
void Function(int def_val = 0)
{
}
Using this, submitting all arguments explicitly works perfectly well:
WrappedCall(Function, 0);
But attempting to make use of the default value fails ('too few arguments to function f(args...)'):
WrappedCall(Function);
How can I work around this? The structure of the code achieving this behavior can be completely different to the example I've written, but I would like, if possible, to maintain the simple calling pattern, as I want to use this on functions from some libraries that can have really long signatures.
You can use a lambda expression:
WrappedCall([](){Function();} );
Default arguments are actually rather limited. This fails for the same reason:
void(*f)(int) = Function;
f(); // error too few arguments :/
Somehow you need to turn Function into a callable whose type allows to be called without arguments. And the lambda achieves that.
If your Function has more non-defaulted arguments this works as well:
template <typename Function, typename ... Args>
void WrappedCall(Function f, Args ... args)
{
//Do something before the call...
f(args...);
//Do something after the call...
}
void Function(int x,double y, float z,int def_val = 0)
{
}
int main() {
WrappedCall([](auto&&...args){Function(args...);},0,0.0,0.0);
}
PS: I didn't consider perfect forwarding here, as it is also missing from your code, but you should definitely read about it.