Convert between std::function with different signatures (T* arg to void* arg) - c++

Question

Is there a way to convert a std::function that has to a T* argument to similar one that has a void* argument? It seems possible since the calls should be compatible at the binary level.
As an example, how can I make this work without turning Producer into a template or losing type safety?
#include <functional>
struct Producer {
// produces an int from a callable and an address
template<class Src>
Producer(Src& src, std::function<int (Src*)> f)
: arg_(&src),
f_(f)
{}
int operator()() {
return f_(arg_);
}
// type erasure through void* but still type safe since ctor
// checks that *arg_ and f are consistent
void* arg_;
std::function<int (void*)> f_;
};
int func1(char* c) {
return *c;
}
int func2(int* i) {
return *i;
}
int try_it() {
char c = 'a';
char i = 5;
// we want to make these work
Producer p1(c, func1);
Producer p2(i, func2);
// but we still want this to fail to compile
// Producer p3(c, func2);
return p1() + p2();
}
Edit: Solution with definite UDB but correct behavior. :-/

Answer 1

You could just not take the argument as a std::function, and then you won't have to worry about it. Take any type F, as long as you can call it with a Src* and it returns something that can be converted to int. Start with a SFINAE-friendly std::result_of_t (borrowed shamelessly from Yakk):
template<class F, class...Args>
using invoke_result = decltype( std::declval<F>()(std::declval<Args>()...));
And use that to SFINAE your constructor:
template<class Src,
class F,
class = std::enable_if_t<
std::is_convertible<invoke_result<F, Src*>, int>::value
>>
Producer(Src& src, F f)
: arg_(&src)
, f_([f = std::move(f)](void* arg){
return f(static_cast<Src*>(arg));
})
{ }
No UB there. This also correctly rejects your p3 case. Furthermore, you don't even need arg_ unless you're using it for some other reason. Store f_ as:
std::function<int ()> f_;
and stick the Src in it:
template<class Src,
class F,
class = std::enable_if_t<
std::is_convertible<invoke_result<F, Src*>, int>::value
>>
Producer(Src& src, F f)
: f_([&src, f = std::move(f)](){
return f(&src);
})
{ }