Can a derived class pointer be converted into a pointer to its public base class?

Answer 1

Yes, via a static up-cast. Up-casting to a base class is always safe so there's no need to dynamically cast (dynamic casting is only a requirement when down-casting, but even then that's usually a sign of a poorly-designed virtual interface).

Consider the following classes:

class A{};

class B : public class A{};

If we create an instance of B we can then point at that instance using a derived class pointer:

B b;

B* pb = &b;

To "convert" pb to a base class pointer we statically cast it like so:

A* pa = (A*) pb;

Or, more simply, we can just point at the derivative's address:

A* pa = &b;

Note that we don't actually convert anything. Although pa points to the base class, the actual instance we're pointing at is still a derived class. This is what enables us to pass pointers and references to derived classes into functions that actually expect pointers or references to base classes. Even though those functions can have no prior knowledge of what derivatives it might receive in the future, they simply don't have to. As far as the functions are concerned, you've passed a base class, not a derivative. But if you call a virtual method of the base class then the derived class method will be called instead -- and that's precisely what one expects of a derivative. This is how inheritance and polymorphism work.

If you really want to convert to a base class (completely eliminating the derived class), then you must call the base class copy constructor, passing the derived class as the argument:

B b;

A a(b);

Note that a and b are now completely separate instances and a is nothing more than the base class component of b, devoid of all its derived class components. Thus if you were to mutate a, you will not mutate b, and vice versa. The casts shown previously do not create separate instances -- there is only the one instance -- so any mutations affect all pointers to that one instance, whether they be base class pointers or derived class pointers.

You can also use the copy constructor to point at a new instance of the base class, creating the new instance on the heap rather than the stack:

A* pa = new A(b);

In order to make use of A's assignment operator, you must provide a cast operator in B:

class B : public A

{

public:

operator A(){return(A(*this));}

};

Now you can perform the following assignment:

A a;

B b;

a = b;

Note that a and b remain completely separate instances.