How do I create an array of method pointers in C++?

Question

The problem is, although these methods have the same signature, they are in different classes. Those classes inherit from one same class.

For example:

class A : public Base {
    virtual bool work();
}

class B : public Base {
    virtual bool work();
}

And I need to create an array of pointers to the methods A::work and B::work, in another class.

Edit 1:

I decided to go with Useless's suggestion, option 1:

vector<Base*> units;
Base *a = new A();
Base *b = new B();
units.push_back(a);
units.push_back(b);

Thanks

Can't you just make an array of pointers to the members of the base class? Something like `bool (Base::*array)[2];`? — , May 28 '13 at 16:40
`bool (*Base::work)()` should be viable as long `work()` is defined in `Base`. — πάντα ῥεῖ, May 28 '13 at 16:40
I have to ask: Is there a reason you aren't just making a virtual call instead of trying to utilize function pointers here? — Mark B, May 28 '13 at 16:41
Are you sure you're asking about your problem, and not about the solution you had in mind? — StoryTeller - Unslander Monica, May 28 '13 at 16:43
@Mark B Yes, I need to create an array of function pointers so that I can then choose one function at random. — user2381422, May 28 '13 at 16:43
How would you call a randomly selected function? You need to know somehow whether it's from A or from B. — n. m. could be an AI, May 28 '13 at 16:45
Just have an array of 'Base' class pointers. Then you can just call the virtual "work" function, after choosing a random pointer from the array. — BTownTKD, May 28 '13 at 16:51
Just to be clear, A::work and B::work don't actually have the same signature: there is an implicit A* and B* this reference argument there. Salagar's std::function is the way to go. — IdeaHat, May 28 '13 at 17:16
They do have the same signature, _if_ there is also a `virtual bool Base::work()`. — Useless, May 28 '13 at 19:12

Useless · Accepted Answer · 2013-05-28T17:09:01.263

First option:

if the different methods are just a implementations of the same virtual method in different subclasses, ie. Base looks like:

class Base {
public:
    virtual bool work() = 0;
}

Then all of your method pointers have type bool (Base::*)(). In this case, your problem is choosing an object to call this method on, so you presumably have a container of Base* pointers with different dynamic types.

Second option:

your classes are really unrelated, and you just want to call some function with signature bool (*)() without worrying about the object.

In this case, either:

your classes and their instances are really irrelevant and you could just use static methods
- so just use free functions
you need an instance but don't know what type it is when choosing the function
- you need a functor which can capture the instance, and provide a compatible nullary call operator. As has already been suggested, std::function<bool()> is the simplest way. For example, you could populate a vector like so:
```
std::vector<std::function<bool()>> fvec() {
    A a;
    B b;
    std::vector<std::function<bool()>> funcs;
    funcs.push_back( [a]() { return a.work(); } );
    funcs.push_back( [b]() { return b.work(); } );
    return funcs;
}
```
  Note that the a and b objects are captured by value in the lambdas, so it no longer matters whether A and B have any kind of inheritance relationship.

They're pretty similar. I find the lambdas slightly more readable, but Edward could quite reasonably disagree. Also, as Salgar pointed out, you can use the Boost equivalent of Edwards code if you don't have C++11 yet. — Useless, May 29 '13 at 07:45
By the way Useless, I edited my original post. Is that what you meant by your first option? — user2381422, May 29 '13 at 07:49
Exactly, if `work` is the only function you're going to call. — Useless, May 29 '13 at 08:08

score 4 · Answer 2 · edited May 23 '17 at 12:18

4

create an array (std::vector) of std::function

With std::function you can use std::bind to make a function pointer to any member function. For member functions you have to also bind to a specific instance of the object.

Here is an example of how to use it. std::function to member function

If you do not have c++11 access, you can do the same with boost::bind and boost::function

edited May 23 '17 at 12:18

Community

1
1

answered May 28 '13 at 16:42

Salgar

7,687
1
25
39

score 2 · Answer 3 · answered May 28 '13 at 16:45

2

You can use a combination of std::function and std::bind both of which are found in <functional>.

Example:

#include <functional>
#include <vector>

class Base
{
public:
    virtual bool work() = 0;
};

class A : public Base
{
public:
    bool work() {return true;}
};

class B : public Base
{
public:
    bool work() {return false;}
};

int main()
{
    std::vector<std::function<bool(void)>> list;

    A t1;
    B t2;

    list.push_back(std::bind(&A::work, t1));
    list.push_back(std::bind(&B::work, t2));

    for (auto& i : list)
    {
        printf("%s\n", (i()) ? "true" : "false");
    }
}

Outputs:

true
false

answered May 28 '13 at 16:45

Edward A

2,291
2
18
31

Do you think this is better than the approach by Useless above? – user2381422 May 29 '13 at 07:32
1

@user2381422 As Useless said, they're fairly similar, however I don't see the point of using a lambda that calls the function, it adds levels of indirection, honestly, I find the `bind` option cleaner, this is what I'd use. Also, using `bind` + `function` means you can use all three options, lambdas, pointers, references. – Edward A May 29 '13 at 07:52

score 1 · Answer 4 · answered May 28 '13 at 16:53

Well, technically you can create an array of pointers to member functions, although as others suggested, you probably shouldn't. This works:

class Base {
    public:
    bool work()
    {
        return true;
    }
};

int main()
{
    bool (Base::*arr[2])() = { &Base::work, &Base::work };
    return 0;
}

How do I create an array of method pointers in C++?

4 Answers4

First option:

Second option:

Linked