Question

So this is probably a weird question, but I have a reasonably good reason for asking.

The gist of my question is, given an example with two levels of derivation on a class hierarchy:

Main Base Class:

class Animal
{
  virtual void Draw() = 0;
};

Derived Class:

class Dog : public Animal
{
  virtual void Draw()
  {
    // draw a generic dog icon or something...
  }
};

Further Derivation:

class Corgi : public Dog
{
  virtual void Draw()
  {
    // draw a corgi icon...
  }
};

Now, I’d love to be able to, from within the Corgi class, permanently downcast the ‘this’ pointer to a Dog pointer and then pass it off somewhere else as an Animal. This other place will then be able to call the Draw function and get the Dog method, not the virtual Corgi method. I know this is strange, but again, I have a vaguely legitimate reason for wanting to do it.

I’ve tried all the different casting operators and haven’t had any luck, but maybe there is a consistent way of pulling this off? In the past I’ve caused myself trouble by not properly using dynamic_cast which resulted in a similar state for a pointer. Perhaps this time I can use that to my advantage?

Edit:
Perhaps the above example doesn’t illustrate clearly the what I’m trying to achieve, so I’ll elaborate with my real goal.

I’m trying to achieve a shorthand for registering base class implementations that link into a scripting system I’ve been using for a while. The scripting system relies on a base class IScriptContext to facilitate access to real-code functions and member variable access. Internally base classes register their member function addresses and member variable addresses which are later dispatched/accessed through lookup tables. I’m in the process of adding proper support for class derivation hierarchies to the scripting system, and I figured being able to isolate the base class versions of these interfaces would help save time and make the whole process cleaner for me when it comes time to register available base classes with the script interpreter. There are other ways to achieve this, such as registering class specific function pointers for each required method for each available base class (e.g. this->Dog::CallFunction, this->Dog::SetMember, this->Dog::GetMember.) However, I figured using an interface would allow me to modify things a bit easier down the road if I ever needed to.

I hope all of that makes some kind of sense.

Thanks!

Answer 1

You have a Corgi object. You can:

1. Treat it as a Dog object everywhere by using the Dog:: qualifier to all calls (e.g. ptr->Dog::draw();). This loses you virtual dispatch, and is almost certainly not what you want from how your question reads.

2. Actually construct a new Dog object from your Corgi. Just do this with a normal static_cast as you’d convert any other type or let implicit conversion take over (e.g. Corgi c; Dog d(c);).

These are the options available to you. To want to retain a Corgi but automatically pretend everywhere that it’s a Dog is neither reasonable nor legitimate, so the language does not provide for it.