Question

Suppose I have a class Dog that inherits from a class Animal. What is the difference between these two lines of code?

    Animal *a = new Dog();
    Dog *d = new Dog();

In one, the pointer is for the base class, and in the other, the pointer is for the derived class. But when would this distinction become important? For polymorphism, either one would work exactly the same, right?

Answer 1

For all purposes of type-checking, the compiler treats a as if it could point to any Animal, even though you know it points to a Dog:

• You can’t pass a to a function expecting a Dog*.
• You can’t do a->fetchStick(), where fetchStick is a member function of Dog but not Animal.
• Dog *d2 = dynamic_cast<Dog*>(d) is probably just a pointer copy on your compiler. Dog *d3 = dynamic_cast<Dog*>(a) probably isn’t (I’m speculating here, I’m not going to bother checking on any compiler. The point is: the compiler likely makes different assumptions about a and d when transforming code).
• etc.

You can call virtual functions (that is, the defined polymorphic interface) of Animal equally through either of them, with the same effect. Assuming Dog hasn’t hidden them, anyway (good point, JaredPar).

For non-virtual functions which are defined in Animal, and also defined (overloaded) in Dog, calling that function via a is different from calling it via d.