Invoking a function from a list of function pointers with variable arguments

Question

On the one hand, I have a list of function pointers to a bunch of functions with different signatures stored in a map that maps each function to a function ID. The function pointers are typedefed within templated classes, such as:

typedef R (T::*SetPtr_t) (A)
typedef R (T::*SetPtr_t) (A, B)
typedef R (T::*SetPtr_t) (A, B, C)

etc.

On the other hand, I have another map that maps the same function ID to a block of memory that stores the parameters to the function.

What I'm looking for is an automated way of invoking a function through the function pointer from the first map by passing the arguments stored in a contiguous block of memory from the second map. I'm looking for a way of making it so that I don't have to hand-code each and every case where I would extract the arguments and pass them into the function, as there are hundreds of these functions.

As to the problem we're trying to solve, we are basically trying to avoid having to hand-code a lot of these function calls, and it's worked well for the case where you only have functions that take in one parameter which is what the design was originally for. The problems start when you try to support having variable number of arguments.

The only thing I have found so far is storing the parameters on the stack and invoking the function manually, something like this: C manually call function with stack and register But that solution seemed too messy. I was hoping for something more C++-like if possible.

Hopefully the question is at least clear enough.

How is this map declared? In particular, how is the function pointer declared? — John Dibling, Jan 27 '14 at 20:13
the C++ way to do this is probably completely different to how you are currently approaching it. In short, in the "X vs Y problem" the C++ way to solve this probably approaches the "X" part differently than you have. What is the functionality you are trying to get here? — IdeaHat, Jan 27 '14 at 20:14
_'Hopefully the question is at least clear enough.'_ No! Add code samples you have tried to the question (**Do not comment, edit!**) — πάντα ῥεῖ, Jan 27 '14 at 20:33
Without getting into too much detail, the function pointers are typedefed within templated classes, as: typedef R (T::*SetPtr_t) (A) typedef R (T::*SetPtr_t) (A, B) ... Then the map contains these objects through which I have access to the function pointer. — user3240947, Jan 27 '14 at 20:34
How are you storing the parameters in memory? Are you married to that method? Why did you choose the above design, and what problem was it trying to solve? — Yakk - Adam Nevraumont, Jan 27 '14 at 20:34
Have you looked at Boost? is there something in there that will meet your needs bind, maybe? — Grady Player, Jan 27 '14 at 20:42
The design was inherited, and I'm trying to resolve the issue without a redesign. — user3240947, Jan 27 '14 at 20:43

score 0 · Answer 1 · answered Jan 27 '14 at 23:14

Well, as Grady Player has commented on the Original Post, function objects and bind (either boost::bind/boost::function or std::bind/std::function from C++11) are usually the way to go if you need to store function calls (either function pointers or functors) and their parameters.

Most probably you could store the parameters in your map as bind objects instead, and simply call the bind/function object which would take care of calling the original function with its bound arguments.

On the other hand, if you prefer or need to keep the current map, instead of hand-writing the calls, you may use a variadic template function (a C++11 feature) to generate them, like:

template<typename R, typename...ParameterTypes typename... ArgumentTypes>
void execute( R (*func)(ParameterTypes...), ArgumentTypes... arguments )
{
    func( static_cast<ParameterTypes...>( arguments... ) );
}

where static_cast is just an example of convertion or unpacking you may need to do in order to "adapt" the arguments structure you're holding in your map to the actual call arguments.

It's hard to give any better advice without more specific information about your particular situation, but I believe bind and/or variadic tempaltes might be a way to solve it.

Invoking a function from a list of function pointers with variable arguments

1 Answers1