C ++继承在子类的变量上调用child的函数

Question

In C++ I have a base class Packet and then a lot of children APIPacket, DataIOPacket etc. Now I want to store an incoming packet and since I don't know the type I store this in a variable:

Packet packet;
packet = DataIOPacket();

But now DataIOPacket has a function getAnalogData(); I can't do:

packet.getAnalogData();

Since packet doesn't have this function. In java I think this is possible since the actual type of the object stored in packet is not lost (is this correct?). But in C++ my DataIOPacket is narrowed into a Packed and loses it's functions that haven't been declared in Packet.

You could make a virtual function in Packet for every function in every child. But for me this would mean a lot of functions in Packet which in most cases should not be called. It has no use calling getAnalogData() on an APIPacket.

How is this problem solved? I can't find the answer but I feel a lot of people must encounter it.

You could do something with typecasting back to DataIOPacket and APIPacket but this doesn't really seem a clean solution either.

Are there maybe libraries that solve my problem?

Rgds,

Roel

Answer 1

This is possible in java and in c++ too. you need to do a dynamic_cast to check for the type.

 Packet* packet;
packet = new DataIOPacket();

      DataIOPacket dio* = dynamic_cast<DataIOPacket*>(packet); 
            if (dio != 0)
            {
             dio->DoSomeChildMethodStuff();
            }

Answer 2

in C++ my DataIOPacket is narrowed into a Packet and loses it's functions that haven't been declared in Packet

It happens because you assign the object of type DataIOPacket to the object of type Packet , which results in this object being sliced (see What is object slicing? ).

What you are actually looking for is a way how you could find out in run-time , whether the object that you are working with has been created as an instance of DataIOPacket . In other words you are looking for Run-Time Type Identification (RTTI) .

To avoid slicing , you need to have a reference or a pointer to the object. Type of this object will be then identified in run-time :

Packet* packet;
packet = new DataIOPacket();

now packet is a pointer to the object of type DataIOPacket ( run-time ), but the type of the pointer is Packet* ( compile time ). In order to invoke a method that is specific for DataIOPacket class on this object, the compiler needs to know that this pointer points to the object of type that provides that method. A proper way of down-casting a pointer to the polymorphic type is by using dynamic_cast , which returns NULL in case that this object can't be cast to this type:

Packet* packet;
packet = new DataIOPacket();
DataIOPacket* dataIOPacket = dynamic_cast<DataIOPacket*>(packet);
if (dataIOPacket)
    dataIOPacket->getAnalogData();

Note that this is also possible with objects with automatic storage duration:

DataIOPacket packet;
Packet* pPacket = &packet;

DataIOPacket* dataIOPacket = dynamic_cast<DataIOPacket*>(pPacket);
if (dataIOPacket)
    dataIOPacket->getAnalogData();

In this case the type of the packet is the crucial factor that decides whether dynamic_cast will succeed or not. The object has to be created as an instance of DataIOPacket in order to call the getAnalogData method on it.

Answer 3

Ok I figured out like some people suggested, that having to dynamic cast suggests my structure is wrong. So I am going to change things that each type of packets gets it's own storage space. I am storing packets where I read them in and they are then passed on to a main thread that does all the processing. Indeed it makes more sense that you keep the type. My main thread doesn't want to figure out which type the packets have since it has a different way to deal with different packets. If you would ever need the behavior I described in my question I think dynamic cast is the way to go. But before doing so you should really ask yourself if you shouldn't change the structure. And using a dynamic cast will not work on objects since they are undergoing slicing. It only works on pointers.