1

Right now, I am trying to call a function in C++ through a Json object. The Json object would provide me with the name of the callee function and all the parameters. I will be able to extract the parameters using a for loop, but I am not sure how I can pass them in. For loop only allows me to pass arguments one by one, and I did not find a way to call a function besides passing in all the arguments at once. I've made a temporary solution of:

if (parameter_count == 1) func(param_1); if (parameter_count == 2) func(param_1, param_2); ...

This solution seems would not work for all cases since it can only work for functions with a limited number of arguments (depending on how many ifs I write). Is there a better way for this? Thanks!

EDIT: Sorry if I was being unclear. I do not know anything about func. I will be reading func from DLL based on its string name. Since I can't really change the function itself, I wouldn't be able to pass in a vector or struct directly.

Or perhaps did I have the wrong understanding? Are we allowed to pass in a single vector in place of a lot of parameters?

Sorry for making a mess through so many edits on this question. Brandon's solution with libffi works. Thanks!

Improve this question
7
  • 2
    Put the arguments in a vector and pass a reference to that. OTOH you can use variable arguments like printf does with a loss of type safety. Depends on how restricted the function you are passing to is and what variation in types you are trying to pass. More details might help Commented Jul 16, 2021 at 20:00
  • 2
    If you want to stay in the type system, check out variadic function templates. Commented Jul 16, 2021 at 20:07
  • If they're all the same type, why not just use a std::vector<type>? Possibly passing by reference. Since it appears that you don't know until runtime how many parameters there will be. Commented Jul 16, 2021 at 20:07
  • 1
    You can retrieve the function by name with GetProcAddress or dlsym for example (if it is a C function or exported function), then you could also write the x86_64 ABI code for calling the function.. assuming you're running x86_64 anyway.. OR use libffi to call it. This is alternative to the comments above. Commented Jul 16, 2021 at 20:38
  • 1
    IMHO, you should place the parameters into a structure or class. This will keep the function declaration constant. It also provides the capability of extending the class or struct through inheritance. Commented Jul 16, 2021 at 21:14

1 Answer 1

Reset to default
1

So the problem as I understand it is that you have a void * pointer (which would come from your platform's DLL loading code) which "secretly" is a pointer to a function with a signature which is only known at runtime. You'd like to call this function at runtime with specified arguments.

Unfortunately, this is not possible to do cleanly with standard C++ alone. C++ cannot work with types that are not present in the program at compile-time, and since there is an infinite number of potential function signatures involved here there is no way to compile them all in.

What you'll want to do instead is manually set up the stack frame on your call stack and then jump to it, either via inline assembly or via some library or compiler extension that accomplishes this for your platform.

Here is a simple example of doing this via inline assembly. (To do this in general you will need to learn your platform's calling convention in detail, and needless to say this will constrain your program to the platform(s) you've implemented this for.)

I haven't actually tried it, but gcc has a compiler extension __builtin_apply that is apparently just meant to forward the arguments from one method wholesale to another but which could perhaps be used to accomplish something like this if you learned the (apparently opaque) description of the method.

[Update: Apparently I missed this in the comments, but Brandon mentioned libffi, a library which implements a bunch of platforms' calling conventions. This sounds like it might be the best option if you want to take this sort of approach.]

A final option would be to constrain the allowed signatures of your functions to a specified list, e.g. something like

switch(mySignature) { case VOID_VOID: dynamic_cast<std::function<void(void)> *>(myPtr)(); break; case VOID_INT: dynamic_cast<std::function<void(int)> *>(myPtr)(my_int_arg_1); break; // ... }

(Syntax of the above may not be 100% correct; I haven't tested it yet.) Whether this approach is sensible for your purposes depends on what you're doing.

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

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.