Quote:Original post by SiCrane
If your base class has virtual functions (and it should at least have a virtual destructor) you can use a dynamic_cast.

And check if the result is a valid pointer (i.e. != NULL)

Quote:Original post by johnnyBravo
Hi i'm using c++, and I've got a Base class and then I have the Draw, Input, Sound and many more classes inheirting off it.

If I were to have a situation like so below:
Base * b = someInstanceOfBaseOrDrawOrInputOrEtcClass;

How would I check if the pointer is pointing to a Draw class instance and not some other?

eg I would do a check if it is a Draw class first before doing this below, if it isn't I would just call an exception:
((Draw)b).someDrawFunc();

Thanks,

ummm, what do Input, Draw and Sound (and many more) have in common?

if you have to know the types of all the individual classes, then the Base class probably isnt going to work out.

im just wondering as to why you've decided to do it this way.

That's fine. Typically, you derive everything from class Interface (your Base), and implement the function getInterface() on Interface:

class Interface {  public:    virtual void addRef() = 0;    virtual void release() = 0;    virtual bool getInterface( char const * name, Interface ** oInterface ) = 0;    template< class T >    bool getInterface( T ** oT ) {      Interface * i;      bool ret = getInterface( typeid(T).name(), &i );      if( ret ) {        *oT = static_cast< T * >( i );      }      return ret;    }};

The implementation for getInterface() in "Sound" would look something like:

bool Sound::getInterface( char const * name, Interface ** oInterface ) {  if( !strcmp( name, typeid(Sound).name() ) ) {    *oInterface = this;    addRef();    return true;  }  return false;}

You can then use containment to attach functionality to the main program:

class Main : public Interface {  public:    void setInterface( char const * name, Interface * i );    template< class T >    void setInterface( T * t ) {      setInterface( typeid( T ).name(), i );    }    ...  private:    std::map< std::string, IfPtr > ifs_;};bool Main::setInterface( char const * name, Interface * i ) {  ifs_[name] = i; // let IfPtr do its job}bool Main::getInterface( char const * name, Interface ** oInterface ) {  std::map< std::string, IfPtr >::iterator i = ifs_.find( name );  if( i != ifs_.end() ) {    *oInterface = (*i).second;    (*oInterface)->addRef();    return true;  }  return false;}

Thus, you could create arbitrary components, and add them to the Main class, and then retrieve them back by interface name (if present). Using the Typeid versions makes the system (mostly) type safe -- if you put in a Sound interface pointer, you'll get back that pointer, static-cast to the right type. The static_cast<> makes sure that you have the right headers included to do the down-cast safely.

This is somewhat similar to how COM does dynamic type discovery, although COM also uses QueryInterface() for manufacturing new instances, which I think is the job of a specific factory function, rather than just QueryInterface. I e, I think your Sound interface should have a makeSoundInstance() member function which returned sound instances, rather than implementing that through overloading getInterface().

Also, for Glak: casts are sometimes useful -- such as in this case. There's no particular feature missing from C++ (unless you count truly dynamic dispatch), but this is pretty well-recognized as a case where down-casting makes sense.