Creating a map of __stdcall

Question

I'm trying to create a map of function names and function pointers using __stdcall. Here is how I currently get my function pointers:

typedef int (CALLBACK* InitializeDLL)(int,int);
InitializeDLL initializeDLL = (InitializeDLL)GetProcAddress(hInstanceLibrary, "InitializeDLL");

and now my Map:

map<string, int *__stdcall> mapInt;
mapInt["InitializeDLL"] = initializeDLL; //throws error for "InitializeDLL cannot be assigned to entity of type int*"

That error is exactly what I expected, but I need to add a type apparently in front of __stdcall. If I remove the "int" in the front then it complains with:

Error: expected a type specifier

If I try to compile it after only creating the map object with the "int" included in the front, it throws the error:

error C2059: syntax error : '>'

Which does not make much sense to me. So what is the correct way to use __stdcall as a type for a map? Adding the int in front of it seemed suspicious to me, but if I don't add it then it complains that it needs a type specified.

Also, CALLBACK is a #define for __stdcall if that is confusing.

http://stackoverflow.com/questions/8304582/how-to-store-functional-objects-with-difrent-signature-in-a-container-eg-std#8304694 — Mooing Duck, Jun 20 '12 at 18:27
`__stdcall` is no more a type than `const` is. They're just modifiers of a type. — Mooing Duck, Jun 20 '12 at 18:28

score 4 · Answer 1 · answered Jun 20 '12 at 16:53

4

You are using __stdcall like a type, but it isn’t one. You need to use your function pointer type in the map definition.

map<string, InitializeDLL> mapInt;

I’m not sure why you tried to do something else in the first place, since you already used this type elsewhere, shouldn’t it have been obvious that it was needed here as well?

answered Jun 20 '12 at 16:53

Konrad Rudolph

530,221
131
937
1,214

Well that would be pointless to have a map with InitializeDLL, because then I would need to create a map for every function and defeat the purpose of using maps in the first place. I thought that __stdcall was some way to get a function pointer, but as explained to me in the chat it's no different than trying to pass something like 'const' as a type. – telkins Jun 20 '12 at 16:59
2

@Atlos: Even if you could use `__stdcall` as a type, how does it get you any closer than `void*`? You still need much more information in order to actually use the pointer. – tenfour Jun 20 '12 at 17:05

Emile Cormier · Accepted Answer · 2012-06-21T18:00:17.053

A function pointer type is not limited to a single function. For instance, your InitializeDLL function pointer type can hold a pointer to any function that has this signature: int foo(int,int).

Perhaps CallbackFunction would be a better name for that typedef, since it encompasses all functions having a signature that can used for a callback:

typedef int (CALLBACK* CallbackFunction)(int,int);
CallbackFunction initializeDLL =
    (InitializeDLL)GetProcAddress(hInstanceLibrary, "InitializeDLL");
map<string, CallbackFunction> mapInt;
mapInt["InitializeDLL"] = initializeDLL;

There are more generic ways to handle functions (and even member functions). If you're capable/willing to use new C++11 features, you can use std::function and std::bind. If not, then you can use boost::function and boost::bind. The Boost and C++11 versions of those facilities are used in exactly the same way. The Boost documentation will be a lot more helpful than cppreference.

If you show us how you intend to invoke the callback functions in your map (including cases where the function signatures are different), I might be able to show you examples on how to use function and bind for your use case.

You might consider having all your command callbacks have the same function signature, then have each callback be responsible for extracting whatever parameters they need to do their work. The object that contains the command parameters can be passed as an argument to the callback function.

You can also consider passing a list of parameters to your callback functions in the form of std::vector<boost::any> or std::vector<boost::variant>. The callback function then converts each boost::any or boost::variant to the specific type associated with that particular parameter. If the command parameter types are of simple built-in types, you can even use std:vector<UnionOfPossibleParameterTypes>, where UnionOfPossibleParameterTypes is a plain old C-style union.

This is more along the lines of what I was thinking, but I will still end up having a lot of variations of CallbackFunction for different return types and parameter configurations. There's no generic way to point to any CALLBACK* typedef that I make? — telkins, Jun 20 '12 at 18:09
In the interest of time, I went with the cop-out of manually comparing each function name string to a list of known functions and then selecting the appropriate command. I'll give the more "elegant" way a shot at another time. — telkins, Jun 20 '12 at 19:26

Creating a map of __stdcall

2 Answers2