What type can hold member-function-pointers of difference classes in C++?

Question

Hi all,

I need an array to hold member-function-pointers of different classes. How can I define the array?

The code should look like this :

arr[0] = &CMyClass::FuncX;
arr[1] = &CYourClass::FuncY;
arr[2] = &CHerClass::FuncZ;

I tried void*, but it doesn't work.

Thanks.

Best regards, Zach@Shine

Answer 1

Without know the parameters or return types of the function its hard to define them for you look at this page to get the gist of it or post the declaration of the functions.

Answer 2

You can't; they are all different types and arrays are homogeneous.

Regardless what the arguments are or what the return value is, there is an implicit this which is unique to the class type. The type of a class member pointer is:

return_value (class_type::*)(parameters);

As you can see, because they belong to different classes they will always be a different type. Even if it were the same class, the return_value and parameters would have to be consistent to create an array, otherwise you'd still have different types.

What's the bigger picture? Boost.Bind with Boost.Function comes to mind. Also, virtual functions may solve your problem.

Answer 3

As others have pointed out, you can't store pointers to different kinds of functions directly. You might want to look at the Command template, e.g., from Modern C++ Design, which at least lets you put different invokable "things" (pointers or smart pointers to functions, functors, member functions) into a single thing.

On its own, that probably won't be sufficient -- you'll (apparently) end up with the template instantiated over different types, which produces different types. Those types will all use the same syntax, but won't all go into an array (which demands a single type).

Depending on your constraints, (compile-time vs. run-time indexing, in particular) you may be able to use a Boost::tuple to store a collection of command objects. You can treat that a bit like an array, using numeric indexing to get to an individual item. Unlike a normal array, however:

1. the syntax is a bit ugly, and
2. The indexing has to be done at compile-time (using compile-time constants).

Answer 4

Others have noted why you can't do this. But even if you could, what would you be able to do with it. In order to call a member function pointer, you need to an object of the appropriate type to call it on. So you would need to know the type of each of the member function pointers. You need to take a step back and figure out what it is that you are trying to accomplish.