C++ inheritance downcasting

Question

I have my base class as follows:

class point    //concrete class
{
 ...    //implementation
}

class subpoint : public point  //concrete class
{
...     //implementation
}

How do I cast from a point object to a subpoint object? I have tried all three of the following:

point a;
subpoint* b = dynamic_cast<subpoint*>(&a);
subpoint* b = (subpoint*)a;
subpoint b = (subpoint)a;

What is wrong with these casts?

Answer 1

How do I cast from a point object to a subpoint object?

You can't; unless either point has a conversion operator, or subpoint has a conversion constructor, in which case the object types can be converted with no need for a cast.

You could cast from a point reference (or pointer) to a subpoint reference (or pointer), if the referred object were actually of type subpoint :

subpoint s;

point & a = s;
subpoint & b1 = static_cast<subpoint&>(a);
subpoint & b2 = dynamic_cast<subpoint&>(a);

The first ( static_cast ) is more dangerous; there is no check that the conversion is valid, so if a doesn't refer to a subpoint , then using b1 will have undefined behaviour.

The second ( dynamic_cast ) is safer, but will only work if point is polymorphic (that is, if it has a virtual function). If a refers to an object of incompatible type, then it will throw an exception.

Answer 2

The purpose of a dynamic cast is to "check at run time if an object is of a certain type in the hierarchy". So now let's look at what you have:

1. You have a point object. Not a subpoint.
2. You're asking a dynamic cast if the object is a subpoint. It's not.
3. Because its not a subpoint, dynamic_cast fails - its way of telling you that the object is not the type you're trying to cast it to.

By contrast, this would have worked:

subpoint c;
point *a = &c;
subpoint* b = dynamic_cast<subpoint*>(&a);
subpoint* b = (subpoint*)a;

Answer 3

For the first example, dynamic_cast only works if there's at least one virtual method in the base class. And if the object isn't actually of the type you're trying to cast, it will result in NULL.

For the second example you need &a instead of a , but once you've fixed that you'll get undefined behavior because the object type is wrong.

The third example requires an operator subpoint() method in point to do a conversion while creating a copy.

Answer 4

Overall, this will not work because point is not a subpoint ; only the reverse is true. However, there are other issues as well.

In order:

---

subpoint* b = dynamic_cast<subpoint*>(&a);

dynamic_cast only works on polymorphic types, ie, types that declare at least one virtual function. My guess is that point has no virtual functions, which means it cannot be used with dynamic_cast .

---

subpoint* b = (subpoint*)a;

For this cast to work, point needs to declare a conversion operator to subpoint * , eg, point::operator subpoint *() .

---

subpoint b = (subpoint)a;

For this cast to work, point needs to declare a conversion operator to subpoint or subpoint needs to have a constructor that takes a parameter convertable from point .

Answer 5

What is wrong with these casts?

The fact that you attempt to do them. A point is not a subpoint , I'd be surprised if it worked.

Answer 6

a can't be made into a subpoint . that implementation isn't there.

Answer 7

I know this is an old (nearly ten year old) question, but I ran into this same issue recently.

I'm not sure what the original poster's intention was, but there can be a case where you want to have a base class that you derive subclasses from, and these subclasses only provide methods which act differently from each other, and utilize the same base data, without adding any of their own data elements.

If you need to do this (for some reason), and want to be able to downcast a base/parent object to a child that was originally instantiated as a parent, then you do not want to use virtual methods, as they will work against you, and you will always be forced to use the virtual methods of the class that was instantiated, and no amount of casting will call the child methods.

So, this can certainly be done. It's just not considered to be "safe". Also, you cannot use dynamic_cast here, it must be a static_cast .