Determining when to use a function on certain classes if they inherit an abstract base class

Question

So presume I have a base class Object and an abstract base class Collidable. (Object containing position information and such and Collidable containing virtual void Collide(Object object) = 0. There will then be child classes that inherit Object, but only certain ones will also inherit Collidable. So my question is, if one of those collidable child classes were to check through a list of Object inherited classes, how might it determine if they also inherit Collidable so that they collide with each other and not with objects that aren't collidable?

(To give a more visual look at my question)

class Object
{
protected:
    Position myPosition;

public:
    Object(void);
    ~Object(void);
}

class Collidable
{
protected:
/* ... */

public:
    virtual void Collide(Object& object) = 0;

    Collidable(void);
    ~Collidable(void);
}

class Grass : public Object
{
private:
/* ... */

public:

    Grass(void);
    ~Grass(void);
}

class Wall : public Object, public Collidable
{
private:
/* ... */

public:
    virtual void Collide(Object& object) { /* Collide logic */ }

    Wall(void);
    ~Wall(void);
}

class Monster : public Object, public Collidable
{
private:
/* ... */

public:
    virtual void Collide(Object& object) { /* Collide logic */ }

    Monster(void);
    ~Monster(void);
}

int main()
{
    Monster creature;
    Object* objects[] = { /* list of Grass, Wall, and Monster classes */ };

    for(int i = 0, i < objects.size(); i++)
    {
        //Logical error: not every object is collidable
        creature.Collide(&objects[i]);
    }
}

So here, I have a list of Wall Monster and Grass classes, but Grass is not collidable, however, let's say that it needs to stay in the array with the other classes. How might I determine if the class in the array is Collidable?

( I do apologize if I am somehow way off key here, but I have been researching and studying a bunch of object oriented things recently so I am still in my learning phase here. )

Answer 1

(Note: Some advice especially if you're in the learning phase - if you make sure your example code compiles some baseline, it makes it easier for people to adapt a working version for the part you are asking about. The compiler warnings are also instructive so you can find out about mistakes ahead of time... for instance you're missing a virtual destructor on Object. It can be a distraction if we don't know whether you know why that's bad or not.)

---

You're trying to encode attributes into objects by virtue of what classes they inherit from, and then check for those attributes at runtime.

It is technically possible to use Run-Time-Type-Information, use a dynamic_cast<> and notice when it returns a null pointer.

Grass grass;
cout << dynamic_cast<Collidable *>(&grass) << "\n";

Monster monster;
cout << dynamic_cast<Collidable *>(&monster) << "\n";

When I run that I get:

0
0xbfabb10c

So the grass could be cast, and the monster could not. This reduced case produces a compiler warning as well:

warning: dynamic_cast of ‘Grass grass’ to ‘class Collidable*’ can never succeed [enabled by default]

But this is not really the intent of the C++ methodology. It's better to think along the lines suggested by @bstar55 and having a virtual isCollidable() on all Objects, with some returning false. Or even to consider if there's a difference between an object isn't "collidable" and one that has a collision test that always fails. It depends on the design of your system.

Instead of trying to navigate the class hierarchy at run-time, a better focus is to think about using inheritance or "traits" when doing compile-time work. That's the real beauty of it. But it's a deep topic. I'll just point you to a couple bits like std::is_base_of and a list of other type traits.

Answer 2

You could dynamic_cast to determine whether object is convertible to Collidable like the example below:

int main()
{
  std::vector<Object*> objects{ new Monster(), new Wall(), new Grass() };

  for (auto i : objects){
    if (dynamic_cast<Collidable*>(i)) dynamic_cast<Collidable*>(i)->Collide();
  }
}

Display

Suggestions:

1. foo(void) is deprecated in C++, it's a remnant from C.
2. When use inheritance you have to make the destructor of base classes virtual to assure that destructors are called in correct order.
3. Don't use C raw arrays instead use std::vector.
4. Unlike the example above, don't use raw pointers but rather smart pointers like shared_ptr.