Passing a function as a class field - c++

Question

I have a class(Foo) with a function pointer(fun) as one of its fields. I'm trying to pass a pointer to another function to the class' function pointer so I'll be able to call the outer function using a class method.
#include <functional>
class Foo{
private:
std::function<int(int)>* fun();
public:
Foo(std::function<int(int)>* fun()){
this->fun = fun; //Error: function as left operand
}
void UltraFun(){
this->fun();
}
};
int abc(int x){
//blah blah blah
}
int main(){
Foo f = Foo(&abc)
}
Basically, abc's address should be passed as a parameter in Foo's constructor and assigned to its fun pointer to function. Therefore, whenever I call UltraFun(), abc should be called. But the error I get is in "this->fun = fun" that the left operand is a function.

Answer 1

With
std::function<int(int)>* fun();
you declare fun to be a function that takes no arguments and returns a std::function<int(int)>*. That is probably not what you want.
What you probably want is
std::function<int(int)>* fun;
which makes fun a variable.
Same with the constructor argument, the argument fun is a function that returns a std::function<int(int)>*.
The above is only part of the problem... While &abc is indeed a pointer to a function, it can't be converted to a pointer to a std::function<int(int)>. But it can be used to initialize a std::function<int(int)> object.
You need to make the argument and member variable to not be pointers:
std::function<int(int)> fun;
and
Foo(std::function<int(int)> fun);
Lastly you don't call the function correctly, since it should take an int argument.
You need to pass an argument when calling it:
this->fun(123); // Or some other value

Answer 2

You seem to have some confusion about std::function and function pointers.
std::function<int(int)> * fun(); at class scope declares a function that takes no arguments and returns a std::function<int(int)>*.
std::function<int(int)>* fun() as a function parameter is a function pointer variable (named fun) that points to a function taking nothing and returning a std::function<int(int)>*.
Let's replace std::function<int(int)> with double for clarity:
double* fun(); at class scope declares a function that takes no arguments and returns a double*.
double* fun() as a function parameter is a function pointer variable (named fun) that points to a function taking nothing and returning a double*.
But you do not need to deal with function pointers inside your class at all. std::function does all that for you:
class Foo{
private:
std::function<int(int)> fun;
public:
Foo(std::function<int(int)> fun){
this->fun = fun;
}
void UltraFun(){
this->fun(1); // You must pass an integer!
}
};
https://godbolt.org/z/bW8pq8
std::function<int(int)> can store any function that takes an int and returns an int, you don't need to add more pointers or parentheses or even concern yourself with function pointers. And at no point in this code is it necessary to involve pointers to a std::function.
Note that you intend to deal with a function that takes an int, so you can't just call it without any parameters in UltraFun.
A more limited version without std::function, using function pointers directly instead:
class Foo{
private:
int (*fun)(int);
public:
Foo(int fun(int)){
this->fun = fun;
}
void UltraFun(){
this->fun(1);
}
};
https://godbolt.org/z/JkT9KR