Typecast callback functions - c++

Question

Can I typecast callback functions?
I like to write a library that registers and calls certain callback functions.
int MyCaller::add_callback_function(int (*callback_function)(), byte behaviour) {
this->callback = callback_function;
}
void MyCaller::run() {
int result = this->callback();
}
// ....
int get_number() { return 42; }
MyCaller my_caller;
my_caller.add_callback_function(get_number, 0);
my_caller.run();
However, I would also like to support callback_functions that output a boolean.
bool get_bool() { return true; }
MyCaller my_caller;
my_caller.add_callback_function(get_number, 0);
my_caller.run();
If I try this, my code seems to run fine, but gcc will give a warning: invalid conversion from 'bool (*)()' to 'int (*)()' [-fpermissive].
To avoid this warning, I overloaded my add_callback_function with a slightly different signature:
void MyCaller::add_callback_function(bool (*callback_function)(), byte behaviour) {
// ...
}
However, I'm lost from this point onward. I expected that I could cast any boolean to an integer, and call the original method:
void MyCaller::add_callback_function(bool (*callback_function)(), byte behaviour) {
this->add_callback_function(static_cast<int (*)()>(callback_function), byte behaviour);
}
However, this gives an error: invalid static_cast from type 'bool (*)()' to type 'int (*)()'.
So I seem to be doing something wrong.
Is there a clean way to do this?
For bonus points: My code stores an array of callback functions, and I like to be able to optionally add a context parameter (to e.g. allow calling methods besides functions). I plan to store all these callbacks (with different signatures) as a int (*)(), and typecast them to their proper form before calling them. Would that be the best way, or are there other (perhaps better) ways to handle this?
The alternative I can think of is to only support one very specific callback signature, but that forces users to write wrappers. I like to put that burden on the library.

Answer 1

You can cast one function pointer type to another, but you can only call it if you cast it to the real function pointer type. You can only store them as the wrong signature.
Calling them any other way results in undefined behavior. The most likely symptom will depend on your platforms current calling convention. But really, just don't do it.
The easiest correct solution is to store a
std::function<int()>
this isn't a function pointer, but can store any callback (including a function pointer) that can be copied, moved, and invoked with zero arguments and returns something compatible with an int (which a bool qualifies as).
std::function can also store objects with state. For example:
struct Foo {
int count = 0;
int callback(){ return ++count; }
};
Foo foo;
std::function<int()> f = [&foo]{ return foo.callback(); };
naturally you become responsible for lifetime. Look up "C++ lambdas" to understand the above syntax.