Polymorphism and checking if an object has a certain member method.

Question

I'm developing a GUI library with a friend and we faced the problem of how to determine whether a certain element should be clickable or not (Or movable, or etc.).

We decided to just check if a function exists for a specific object, all gui elements are stored in a vector with pointers to the base class.

So for example if I have

class Base {};
class Derived : public Base
{
    void example() {}
}
vector<Base*> objects;

How would I check if a member of objects has a function named example.

If this isn't possible than what would be a different way to implement optional behaviour like clicking and alike.

Answer 1

I'm not sure it is easy or good to do this by reflection. I think a better way would be to have an interface (somethign like GUIElement) that has a isClickable function. Make your elements implement the interface, and then the ones that are clickable will return true in their implementation of the function. All others will of course return false. When you want to know if something's clickable, just call it's isClickable function. This way you can at runtime change elements from being clickable to non-clickable - if that makes sense in your context.

Answer 2

I would create an interface, make the method(s) part of the interface, and then implement that Interface on any class that should have the functionality.

That would make the most sense when trying to determine if an Object implements some set of functionality (rather than checking for the method name):

class IMoveable
{
    public:
        virtual ~IMoveable() {}
        virtual void Move() = 0;
};

class Base {};

class Derived : public Base, public IMoveable
{
    public:
        virtual void Move()
        {
            // Implementation
        }
}

Now you're no longer checking for method names, but casting to the IMoveable type and calling Move().

Answer 3

The best way to do this is to use mixin multiple inheritance, a.k.a. interfaces.

class HasExample // note no superclass here!
{
    virtual void example() = 0;
};

class Derived : public Base, public HasExample
{
    void example()
    {
        printf("example!\n");
    }
}

vector<Base*> objects;
objects.push_back(new Derived());

Base* p = objects[0];
HasExample* he = dynamic_cast<HasExample*>(p);
if (he)
    he->example();

dynamic_class<>() does a test at runtime whether a given object implements HasExample, and returns either a HasExample* or NULL. However, if you find yourself using HasExample* it's usually a sign you need to rethink your design.

Beware! When using multiple inheritance like this, then (HasExample*)ptr != ptr. Casting a pointer to one of its parents might cause the value of the pointer to change. This is perfectly normal, and inside the method this will be what you expect, but it can cause problems if you're not aware of it.

Edit: Added example of dynamic_cast<>(), because the syntax is weird.

Answer 4

If you're willing to use RTTI . . .

Instead of checking class names, you should create Clickable, Movable, etc classes. Then you can use a dynamic_cast to see if the various elements implement the interface that you are interested in.

IBM has a brief example program illustrating dynamic_cast here.

Answer 5

You could just have a virtual IsClickable() method in your base class:

class Widget {
public:
    virtual bool IsClickable(void) { return false; }
};
class ClickableWidget : public Widget
{
public:
    virtual bool IsClickable(void) { return true; }
}
class SometimesClickableWidget : public Widget
{
public:
    virtual bool IsClickable(void); 
    // More complex logic punted to .cc file.
}
vector<Base*> objects;

This way, objects default to not being clickable. A clickable object either overrides IsClickable() or subclasses ClickableWidget instead of Widget. No fancy metaprogramming needed.

EDIT: To determine if something is clickable:

if(object->IsClickable()) {
   // Hey, it's clickable!
}