Programming

Hi.

I need help with a C/C++ question and i hope someone can help me or give me some ideas.

Is possible to build a function C/C++ call dynamically? I.e, i have an array with pointer functions and these functions can have different number of parameters and types. These parameters and their types are stored in a database that i'll get depending on the function name that i want to execute with a function pointer.

More or less i want to build a function thrower with any parameter.

Can i build the function call dynamically?

Any idea?

If you mean something like printf(), you can build something similar with variable arguments using stdarg.h

Thanks Pludi, but, yes, i know that library, but, what i need is something more complex because i have to build the function call without know the parameter number in programming time. I have a number and a list of parameters (void*).

For example, if i get 2 as parameter number, my function call will be:

Code:

       execute (param[0], param[1]);

and if it is 5:

Code:

    
     execute (param[0], param[1], param[2], param[3], param[4]);

Then, or i have a switch with all the posiblities or i don´t know to do.

To the best of my knowledge, you always have to tell C functions something about their parameters. Taking your example: the function execute should take an arbitrary number of arguments of unknown type, right? So lets say you pass along
As you've said, you've got a number and a list of parameters. Is the number the number of parameters in the list? If so, just use the va_* macros for a function:

Code:

void execute (int numParam, ...);

or even better

Code:

void execute (int numParam, type* params);

If that doesn't suit you, could you give an better example of what you need?

hello
you can use function pointers and call functions dynamically. and use case statements to call the function dynamically
like int (*func1)(arg1,arg2....); //function pointers.

I think the short answer is no. As far as I know, there is no way in C to dynamically control the call stack. You may need to build your own argument list into a structure that can be dynamically composed by the caller and decomposed by the callee. Then, to all your "dynamic" functions, you pass the structure as a single argument.

The only way to use var-args, IMO, would be to know ahead of time the set of argument lists that you can support. You would have to limit the number of items in the set to something manageable by a switch statement. So, for example, if you have 40 procedures and the unique set of argument lists is [ (string), (string, int), (int, int), (string, string, string) ] then you have four different argument lists in the set and you can use a single four item switch statement to make the call after selecting the right function pointer.

However, if you can't limit the number of different argument lists, and you need a generic caller, then things get hairy quickly. No matter what, you have to at least limit the number of types and argument counts you can support. But, the combinations of types and counts quickly increases the number of items in the set that must be supported by the switch statement.

In fact, in the case where you allow (string, int, long) in either 1, 2, or 3 arguments you can have 3+9+27 = 39 different possible argument lists in the set. Make it 1, 2, 3, or 4 arguments it goes up to 120. Make it four different types and four lengths and you will have such a large set you won't want to write the switch statement to manage it; it'll have 4+16+64+256 = 340 switch cases.

As you can see, to make a generic caller in the above cases would get cumbersome.

Quickly, back to the "generic thrower" comment. You must realize that when a function is compiled (in this case your generic thrower function) the compiler configures a stack frame that is large enough to store arguments for the functions called by the "generic thrower". While you could manipulate that stack frame (in an architecture specific way) during runtime to call a function with any arguments you want, the compiler is still in control of the size of the stack frame. Too many, or too large, arguments and you'll overrun the frame and corrupt memory. If you could force the compiler to create a larger than normal stack frame so you'll "never" overrun it then you may be able to read up on how your architecture composes its stack frames to place the arguments into the frame and make a call (with no arguments) to the function and hope what you tweaked into the stack frame sticks around for the function to pick up. But, this won't be pretty code, and it won't be guaranteed to be compatible across different systems.

On more note, I'm not sure all architectures store the arguments for the called function in the frame of the caller. However, I know AIX does. If yours does not, then you're in even bigger trouble because then you need to figure out how to allocate a stack frame yourself, put all the arguments in it, and fire off the call. All of this is, also, architecture specific. And to code it, you're probably looking at dipping into ASM.

Ohhhhhh, thank you very much. You have really understood my problem. I didn´t know if i had explained very well. My english isn´t very good.
Anyway, i am studying a C++ Reflection Library (XCppRefl - C++ Reflection Library), maybe it could serve me.

Sincerely, thank you very much.