Handover function as parameter that has parameters - c++

Question

I want to pass a callback function that has a parameter:
class foo1{
foo1(void (*callback)(float));
};
foo1::foo1(void (*callback)(float)){
//excecute the callback at some point
}
float foo2(){
return 1.1;
}
void foo3(float f){
//do stuff with f
return;
}
int main(){
void (*p3)(float);
//p3 is a pointer to a function that returns void and has a single float as input
p3 = &foo3(foo2());
//p3 now points to foo3 wich fits the requirements. But it does not make sence to give that pointer an argument.
foo1(p3);
return 0;
}
There are several errors and
I understand that this does not make sence. (See comments in the code) But I don't know how to do it corretly. I want to pass a function as callback that has the input value of foo2.

Answer 1

You can do something more like this instead:
class foo1 {
foo1(void (*callback)(float));
};
float foo2();
foo1::foo1(void (*callback)(float)) {
//excecute the callback at some point
callback(foo2());
}
float foo2() {
return 1.1;
}
void foo3(float f) {
//do stuff with f
}
int main() {
void (*p3)(float);
p3 = &foo3;
foo1(p3);
// or simply:
// foo1(&foo3);
return 0;
}
If you do not want foo1() passing a parameter value to the callback, then don't declare the callback with an input parameter to begin with, use another callback function that calls the intended callback function:
class foo1 {
foo1(void (*callback)());
};
foo1::foo1(void (*callback)()) {
//excecute the callback at some point
callback();
}
float foo2() {
return 1.1;
}
void foo3(float f) {
//do stuff with f
}
void foo4() {
foo3(foo2());
}
int main() {
void (*p4)();
p4 = &foo4;
foo1(p4);
// or simply:
// foo1(&foo4);
return 0;
}
Or, in C++11 and later, you can use a lambda:
class foo1 {
template<class T>
foo1(T callback) {
//excecute the callback at some point
callback();
}
};
Or:
#include <functional>
class foo1 {
foo1(std::function<void()> callback) {
//excecute the callback at some point
callback();
}
};
float foo2() {
return 1.1;
}
void foo3(float f) {
//do stuff with f
}
int main() {
foo1([](){ foo3(foo2()); });
return 0;
}
Or, you can use std::bind():
class foo1 {
template <typename T>
foo1(T callback) {
//excecute the callback at some point
callback();
}
};
or:
#include <functional>
class foo1 {
foo1(std::function<void()> callback) {
//excecute the callback at some point
callback();
}
};
#include <functional>
float foo2() {
return 1.1;
}
void foo3(float f) {
//do stuff with f
}
int main() {
foo1(std::bind(foo3, foo2()));
return 0;
}

Answer 2

You can use a lambda to do that.
Something along this way should work:
struct foo1{
template<typename F>
foo1(F f) {
//excecute the callback at some point
f();
}
};
float foo2(){
return 1.1;
}
void foo3(float){
//do stuff with f
return;
}
int main(){
foo1([param{foo2()}](){ foo3(param); });
}
Consider this expression:
[param{foo2()}](){ foo3(param); }
It creates a callable object having type void(void), that is what you expected by applying the result of the execution of foo2 at the first argument of foo3 (right?).
That's why you can simply invoke it as f() within the constructor of foo1.