virtual derived class of a non-virtual base class

Question

I have a virtual class that has been derived from a non virtual class. But when I c-style cast the derived class to base class, the class is corrupted. I am looking at the member variables using the debugger and the member variables are all corrupted when I do that cast. I see there is a 4 byte discrepency when I do that cast(may be the virtual pointer) using debugger. For Ex:

class A//non-virtual class
{
 ~A();
int fd;
};
class B:public A
{
virtual ~B();
};

Now say the address of obj of type B is: 0x9354ed0. Now when I cast it (A*)(0x9354ed0) debugger moves the bytes by 4 bytes. So starting address of the casted obj is 0x935ed4

Is it wrong to cast a derived virtual class to base non-virtual class? What is the reason for 4 byte discrepancy? And what is the right way to cast it? Thanks for any input or explanation.

Answer 1

If that is the shell of the code you are using then you aren't deriving the class B from class A. If you wanted to do that you would need to do this:

class A
{
public:
  virtual ~A();
  // other stuff
};

class B: public A
{
public:
  virtual ~B();
  // other stuff
};

I really don't think you can cast the way that you were hoping to in your question. If you are using virtual functions and derived classes then they need to be declared virtual upon first usage. Plus, I'm not 100% sure but if you have any virtual destructors you need to have all virtual destructors in your heirarchy.

Hope that helps, nmr

Answer 2

Here is what you described.

class A
{
public:
  ~A();
  // other stuff
};

class B: public A
{
public:
  virtual ~B();
  // other stuff
};

It is perfectly legal to derive a class from a non-virtual base class, and to make the derived class virtual. The 4 bytes offset (can be 8) corresponds to a hidden member variable of type pointer that points to the virtual functions table of the class.

Answer 3

1. Its legal to point derived class object using base class pointer thats called run time polymorphism i.e. based on dynamic type of object funtions are dispatched.

2. When you define a class with virtual function,a table comprising of virtual function address is formed called virtual function table. When you declare an object of a class with virtual function , a virtual pointer pointing to corresponding virtual function table is insert into it.

Answer 4

When you cast pointers across the hierarchy, actual numerical pointer values might change. There's nothing wrong with the fact that it changes. There's noting wrong with such a cast. How the numerical pointer values change depend on the physical layout of the class. It is an implementation detail.

In your example, the 4 byte change in pointer value might easily be caused by the presence of virtual table pointer in the derived class.

The change in pointer value will not corrupt any member variables. The example in your original post does not show any "corrupted member variables" and in general your claim about some member variables getting "corrupted" doesn't make much sense. Please, when you make such claims, illustrate them with an example, so that people can understand what on Earth your are talking about.

Update:

The fact that base class subobjects might have non-zero offsets inside the derived classes immediately mean that in order to perform a proper cast from derived pointer type to base pointer type the compiler must know the source type and the destination type and the relationship between them. For example, if you do this

B* pb = /* whatever */;
A* pa = pb;

the compiler will know how to properly offset pointer pa from pointer pb. But of you do this

A* pa = (void *) pb;

the compiler will forget about the relationship between A and B, fail to perform the proper offset and produce the invalid value of pa. The effect would be the same as in

A* pa = reinterpret_cast<A*>(pb);

If you do it this way, the result will be meaningless. So, just don't do it.

Of course, if you manually inspect the numerical value of pb and find out that it is, say, 0x12345678, and then do

A* pa = (A*) 0x12345678;

you will also get completely meaningless results, because the computer has no way to know that it has to perform the proper offset of the pointer.

This will produce an illusion of members of A getting "corrupted", while in fact the only thing that is corrupted is your pointer. And you are the one who corrupted it.

Answer 5

The missing four bytes are, indeed, the vptr of the object; since class A has no vtable, a pointer to A has no vptr.

While it is actually legal deriving a class with virtual methods from another class with none, it is not a good idea. Inheriting from a class with no virtual methods is usually unsound, since that class is not intended to be used polymorphically, which is the main reason behind inheritance. All kinds of bad things can happen if you do it. If you try to use derived class objects through base class pointers, you may well run into the dreaded undefined behaviour (most likely a crash). For instance, trying to delete a base class pointer pointing to a derived class object.