Is it possible to create an array of generic function pointers?

Question

I'm writing an interface layer to a shared library we are opening via dlopen/dlsym. The parameters to the functions may change depending on whether the library is compiled for system A vs system B.

I had a thought that instead of doing a bunch of typedefs, I could try to create an array of all of the function pointers returned from dlsym and then eventually use VA_ARGS to pass in the data. This would also allow me to deal with extensibility-- if the library parameters change, we'd just need to update the calling functions, instead of the typedefs below, too. Basically, I'm looking to change something like this:

typedef int* (*foo_t)(int, int);
typedef int* (*bar_t)(int, int, char*, int);
typedef void (*baz_t)(void);

void GetStuff()
{
  void *handle = dlopen("/my/cool/libLibrary.so", RTLD_LAZY);
  foo_t foo = dlsym(handle, "TheFooFunction");
  bar_t bar = dlsym(handle, "TheBarFunction");
  baz_t baz = dlsym(handle, "TheBazFunction");

  foo(1, 2);
  bar(3, 4, "cool", 5);
  baz();
}

into this:

enum funcs
{
  FUNC_FOO = 0,
  FUNC_BAR = 1,
  FUNC_BAZ = 2,
  FUNC_MAX
};

void funcArray[FUNC_MAX]; // Not legal - looking for a way to do something like this...

char *functionNames[FUNC_MAX] =
{
   [FUNC_FOO] = "TheFooFunction",
   [FUNC_BAR] = "TheBarFunction",
   [FUNC_BAZ] = "TheBazFunction"
};

void GetStuff()
{
  void *handle = dlopen("/my/cool/libLibrary.so", RTLD_LAZY);
  for (int i = 0; i < FUNC_MAX; i++)
  {
    funcArray[i] = dlsym(handle, functionNames[i]);
  }

  funcArray[FUNC_FOO](1, 2);
  funcArray[FUNC_BAR](3, 4, "cool", 5);
  funcArray[FUNC_BAZ]();
}

Is this possible? I know the array of voids is illegal. I can't use uintptr_t in it's place, since those are for data (not function) pointers. Are there any other options other than creating big #define's for each configuration and doing it the original way?

Does this answer your question? How can I use an array of function pointers? — user21926
– user21926, Commented Feb 25, 2020 at 20:00
Unfortunately, no. Those function pointers all have the same signature, which is what allows you to use them in an array like that. This question is for dissimilar function signatures. — Maxthecat
– Maxthecat, Commented Feb 25, 2020 at 20:15
The problem you are trying to solve is not trivial. You must provide a means for marshaling parameters and return values. If there's just the two fixed sets of functions, you're better off #define'ing them in your header files. If any of them change, you have to recompile anyway. — jwdonahue
– jwdonahue, Commented Feb 25, 2020 at 20:34
The C standard does not have anything called VA_ARGS. Are you thinking of the __VA_ARGS__ preproessor feature or the va_arg variable-argument-list feature? What role do you envision it playing? — Eric Postpischil
– Eric Postpischil, Commented Feb 25, 2020 at 20:41
The C standard does not have any function-pointer equivalent for the “universal” object-pointer void *—except that any function-pointer type may serve as a universal function pointer type. All pointer-to-function types may be converted to other pointer-to-function types, and converting back to the original type produces the original pointer (or equivalent). So you can use an array of any function-pointer type of your choosing and manage the pointers with casts. The real question is how you intend to use those pointers—how will you call the functions with the correct arguments. — Eric Postpischil
– Eric Postpischil, Commented Feb 25, 2020 at 20:43

KamilCuk · Accepted Answer · 2020-02-25 21:44:26Z

2

Declare the array as an array of function pointers. Actually the type of function pointer does not matter.

void (*funcArray[FUNC_MAX])();

Then right before you call you have to convert your function pointers to the correct type:

((int *(*)(int, int))funcArray[FUNC_FOO])(1, 2);
((int *(*)(int, int, char*, int))funcArray[FUNC_BAR])(3, 4, "cool", 5);
((void (*)(void))funcArray[FUNC_BAZ])();

answered Feb 25, 2020 at 21:44

KamilCuk

146k8 gold badges84 silver badges154 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Kaz · Accepted Answer · 2020-02-25 21:20:19Z

There are two main ways to achieve run-time selection of the type signature of a function being called.

Have a switch statement somewhere which switches on an integer code (designed by you) indicating the function type. The switch cases are all calls which cast the function pointer differentlly and call it with different arguments.
Use a library for constructing funcction calls dynamically, such as libffi (MIT-like license) or libffcall, (GPL-licensed GNU software).

Option 2 requires more demanding coding and may be overly general for a situation like this. The purpose of these libraries is to support dynamic languages being able to call C libraries. A dynamic language can use libffi or libffcall as a back end for translating the description of a function into an object which can be used to call it.

Option 2 hints at an option 3: Write your program, or a portion of it, in a higher level language that has good FFI, and leverage that to achieve the flexible calls into the shared libraries.

Collectives™ on Stack Overflow

Is it possible to create an array of generic function pointers?

2 Answers 2

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related