What is the nicest way to assign function pointer using class in c++?

Question

I have a 3rd party library and I have to assign function pointers like this:

FunctionsStruct functionsStruct;

functionsStruct.firstFunctionPointer = myFirstFunction;
functionsStruct.secondFunctionPointer = mySecondFunction;
functionsStruct.thirdFunctionPointer = ...;

In myFirstFunction, mySecondFunction I use shared variables. It looks like this:

void myFirstFunction(int a, int b) {
    sharedVariable = 56 * a;
    ...
}

void mySecondFunction(int c) {
    sharedVariable = 21 + c;
    ...
}

Of course I can write a code in this way:

int sharedVariable;

void myFirstFunction(int a, int b) {
    sharedVariable = 56 * a;
    ...
}

void mySecondFunction(int c) {
    sharedVariable = 21 + c;
    ...
}

void setFunctionPointers() {
    FunctionsStruct functionsStruct;

    functionsStruct.firstFunctionPointer = myFirstFunction;
    functionsStruct.secondFunctionPointer = mySecondFunction;
    functionsStruct.thirdFunctionPointer = ...;
}

But I would like to avoid global / static variables + have classes.

So the best for me is something like this ( I know that I can't assign member function address to function pointers - I'm looking for something similar ) :

class A {
public:
    A(int sharedVar): sharedVariable(sharedVar) {};
    int sharedVariable {};
    void myFirstFunction(int a, int b);
    void mySecondFunction(int c);
}

class B {
private:
    A a;
public:
     B() {};
     void setFunctionPointers();  
}

void B::setFunctionPointers() {
    functionsStruct.firstFunctionPointer = &a::myFirstFunction;
    functionsStruct.secondFunctionPointer = &a::mySecondFunction;
    functionsStruct.thirdFunctionPointer = ...;
}

So what is the nicest solution?

you can have function pointers to static member functions, if that helps. — KungPhoo, Mar 07 '23 at 06:45
@KungPhoo Thank you. Yes, this is the possible solution, but static variables are ugly like global variables ;) — Tommmmmm, Mar 07 '23 at 06:50
You cannot avoid it since the signatures are bound to function pointers.. — Louis Go, Mar 07 '23 at 07:13
You cannot avoid global variables using standard C++. There is a *non-standard, not universally portable* way to do it though. though. See https://www.gnu.org/software/libffcall/callback.html — n. m. could be an AI, Mar 07 '23 at 07:26

score -1 · Answer 1 · answered Mar 07 '23 at 07:05

-1

You can use lambda with capturing, and it's dependent on your customization, but I assumed that you have a shared_ptr variable, so I just captured it by copying (increasing the ref-count).

As you said, you can use global (that is ugly in this case) or class, and in this manner, you can use lamda (that is the same as class declaring under skin).


struct FunctionsStruct {
  std::function<void(int, int)> firstFunctionPointer;
  std::function<void(int)> secondFunctionPointer;
};
void setFunctionPointers() {
  FunctionsStruct functionsStruct;
  auto sharedVariable = std::make_shared<int>();
  functionsStruct.firstFunctionPointer =
      [sharedVariable](int a, int b) -> void { *sharedVariable = 56 * a; };

  functionsStruct.secondFunctionPointer = [sharedVariable](int c) -> void {
    *sharedVariable = 21 + c;
  };
}

int main() { return 0; }

answered Mar 07 '23 at 07:05

Another HM

148
10

OP has a thrd party library that uses function pointers, so "use std::function" is not a useful piece of advice. – n. m. could be an AI Mar 07 '23 at 07:11
Sorry I dont know what's difference between function pointer and std::function ? I thought they are same except that lambda wont need naming.[disassembly](https://stackoverflow.com/questions/25520287/lambda-vs-function#answer-25520375) – Another HM Mar 07 '23 at 07:24
They are not the same. – n. m. could be an AI Mar 07 '23 at 07:26

score -1 · Answer 2 · answered Mar 07 '23 at 07:35

This is always a big frustration when using c++ with a c library. But it all depends on the situation.

Some C libraries allow you to store a void* data with your callback, which you could use for c style OOP, or use it to store your this pointer. This does not seem the case for your library.

So i am assuming that the callbacks don't have context, in which case you would use a singleton pattern. and have a function in your cpp file like:

void callback(...){
  MyClass::instance().callback(...);
}

It is a bit hard to give you more, since i don't know the function of the library.

What is the nicest way to assign function pointer using class in c++?

2 Answers2