如何在C ++中向下转换以从父实例调用子函数？

Question

I am trying to call a child function from a parent instance using explicit down-casting (thanks for pointing out @Aconcagua). As a beginner in C++, I have something like this:

Road currentRoad = ...;
duration = ((SpeedDataRoad) currentRoad).getSpeedProfileTime(dateinMillis, isRightDirection);

class SpeedDataRoad inherits from Road :

class SpeedDataRoad : public Road{ 
     double getSpeedProfileTime(long dateinMillis, bool isRightDirection) {

     ...

}

However I am getting the error:

No matching conversion for C-style cast from 'Road' to 'SpeedDataRoad'

Any suggestions on what I am doing wrong would be appreciated.

---

Just to be clear, what I am trying to achieve in Java would be written like this and working correctly:

duration = ((SpeedDataRoad) currentRoad).getSpeedProfileTime(currentTime, isRightDirection);

Answer 1

You suffer from an effect called 'object slicing' :

SpeedDataRoad sdr;
Road currentRoad = sdr;

At the second line, sdr is assigned by value to currentRoad , but the latter is not of appropriate type to hold a complete SpeedDataRoad object. So all surplus pieces of SpeedDataRoad are simply cut away and all that remains is a pure Road object only containing the Road parts of original sdr object.

At the same time, as you only have a pure Road object left, you cannot cast it back to SpeedDataRoad object. From where should the now missing parts come from?

This is exactly the same reason why you cannot place polymorphic types directly into a container (like std::vector ) of the base class.

What you need are either pointers (if you want to be able to re-assign) or references (to be preferred otherwise):

SpeedDataRoad sdr;
Road& currentRoad = sdr;
//  ^ (!)
// or:
Road* currentRoad = &sdr;

Now you can do the cast. But explicit down-casts have a smell of bad design. You might be better off with a polymorphic approach right from the start:

class Road
{
public:
    virtual double getSpeedProfileTime(long, bool) = 0;
    //                                             ^ pure virtual
    // alternatively, you can provide a default implementation
};

class SpeedDataRoad : public Road
{
public:
    double getSpeedProfileTime(long, bool) override
    { /* ... */ }
};

Now you can simply have:

SpeedDataRoad sdr;
Road& currentRoad = sdr;
double profile = currentRoad.getSpeedProfileTime(0, false);

As being virtual, you'll always get the right variant of the function, no matter which sub-class we have at all and in which way it might override the function...

Side note 1: Instead of old C-style casts, you might prefer the more modern C++ casts, you can control more fine grained what you actually want to do:

Road* someRoad = ...;
SpeedDataRoad* sdr = static_cast<SpeedDataRoad*>(someRoad);
SpeedDataRoad* sdr = dynamic_cast<SpeedDataRoad*>(someRoad);

You would use a static_cast , if you are 100% sure that the object only can be of desired type. You avoid any run-time tests that wouldn't serve anything at all in this situation (you are 100% sure anyway, remember?). Curiously recurring template pattern is a typical scenario for.

If you cannot be sure about the type, then dynamic_cast comes into play, it will do some run-time type checking and just return a null pointer (if used on pointers) or throw a std::bad_cast (if used on references), if the actual type is not of desired type (or a sub class of). Such a scenario can arise when different polymorphic types are stored in a vector (as pointers to base class, see above). But again: Needing a cast at all might be a hint to your design being flawed...

(For completeness: There are yet const_cast and reinterpret_cast , but you should stay away from these unless/until you really, really know what you do.)

Side note 2: Differences to Java.

In Java, we differentiate implicitly between native and reference types. Native ones are always passed by value, reference types always by reference – well, Java reference , which actually resembles far more a C++ pointer (can be null , can be re-assigned) than a C++ reference. In Java, this happens implicitly , in C++, you need to be explicit about (on the other hand, you can have both behaviours for any type).

Java cast on (Java!) reference behaves like C++ dynamic_cast (on reference, ie throws, it won't return null on type mismatch).

Finally (concerning my polymorphism recommendation), in Java all functions are implicitly virtual, in C++, you again have to be explicit about (apply the virtual keyword, see above).

Answer 2

You are slicing your SpeedDataRoad object. Unlike Java objects, which have pointer/reference semantics, C++ objects have value semantics. That means, in your example, currentRoad is a Road , not a SpeedDataRoad . It is a copy of the Road part of whatever SppedDataRoad is created in your ... .

To work with polymorphism is C++ you need to use references or pointers. That is, the following will not work because currentRoad is not a SpeedDataRoad :

double foo(Road currentRoad)
{
    //...
    return ((SpeedDataRoad)currentRoad).getSpeedProfileTime(currentTime, isRightDirection);
}

int main()
{
    SpeedDataRoad road;
    foo(road);
}

While the following will work because currentRoad references a SpeedDataRoad :

double foo(Road& currentRoad)
//             ^---------------- Pass by reference now
{
    //...
    return dynamic_cast<SpeedDataRoad&>(currentRoad).getSpeedProfileTime(currentTime, isRightDirection);
    //     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    //     Using C++-style cast and casting reference to reference
}

int main()
{
    SpeedDataRoad road;
    foo(road);
}

In the first example, currentRoad is a copy of the Road part of road , while in the second example currentRoad is a reference to road .

---

You should also avoid C-style casts in C++. In this instance, it would be better to use dynamic_cast<SpeedDataRoad&>(currentRoad) or, if you're absolutely sure currentRoad will always be a reference to a SpeedDataRoad object, static_cast<SpeedDataRoad&>(currentRoad) . The former will do runtime type checking and throw an exception if currentRoad isn't a reference to a SpeedDataRoad while the latter will avoid the (small) overhead of doing runtime type checking, but will result in undefined behavior if currentRoad isn't a reference to a SpeedDataRoad .

Answer 3

That's called a downcast and not an upcast - the straightforward way to this by a dynamic_cast :

if (SpeedDataRoad* sdroad = dynamic_cast<SpeedDataRoad*>(&currentRoad); sdroad != nullptr) {
   duration = sdroad->getSpeedProfileTime(currentTime, isRightDirection);
}

Answer 4

If you want to check inside a function if you can downcast a pointer/refernce into a child, you need to use dynamic cast.

void foo(Road* road){
  SpeedDataRoad* child{nullptr};
  if(child = dynamic_cast<SpeedDaraRoad*>(road){
    // Do something with SpeedDataRoad
  } else {
     // road is not an instance of SpeedDataRoad
  }
}

You can also use dynamic_cast with references, like so

cppSpeedDataRoad& child = dynamic_cast<SpeedDataRoad&>(reference_to_road);

But be carefull, as if the cast fails, std::bad_cast will be throw.

Answer 5

In C++, we try not to use C-style casting. (typename)object . Instead, there are 4 types of type-casting.

1. static_cast<typename*>(pointer) static_cast<typename>(value) : Upcasting of pointers and type-casting for value types

2. dynamic_cast<typename*>(pointer) : Safe-downcasting of pointers (the one you should use). It does a runtime check for upcasting, hence, there is runtime cost.

3. const_cast<...>(...) : Constant type

4. reinterpret_cast<typename*>(pointer) reinterpret_cast<typename>(value) : Similar to C-style cast.

For objects (stack allocated), I rarely use casting. Because naturally objects in C++ has their own size, casting may change their size.