Size of objects during Multilevel/Multiple inheritance [closed]

Question

Closed. This question is not reproducible or was caused by typos. It is not currently accepting answers.

---

This question was caused by a typo or a problem that can no longer be reproduced. While similar questions may be on-topic here, this one was resolved in a way less likely to help future readers.

Closed 8 years ago.

Improve this question

Below is a pseudo declaration for a multilevel inheritance.

Base class ( protected int data)

derived1 : virtual public base ( protected int data1 )

derived2 : virtual public base ( protected int data2)

derived3 : derived1,derived2 ( private int data3 )

Main(){ base b;    derived1 d1;   derived2 d2;   derived3 d3; }

sizeof(b) // 4 which is correct as only int (4bytes)
sizeof(d1) // 12 why not 8 -> 4(base) + 4(derived)
sizeof(d2) // ??? whatever applies above should apply here
sizeof(d3) // 24 why not 12 -> 4(base) + 4(derived1/derived2) + 4(d3).

Does size also include virtual tables also. Again here there cannot be virtual table as no virtual function defined. Please help in clarifying my doubt.

PS: What I have understood till now:

Unless the function is declared virtual in base class,

base *bptr;
 derived d;
 bptr = &d;
 bptr->fun();  // will call the base class function.

But if the fun() is declared virtual then the above code will call derived class fun().

Answer 1

First of all, in your implementation above, you need to return the type of count instead of void.

For example, suppose you've declared int count.

Then you need to return int in the 'postfix' version, and int& or const int& in the 'prefix' version.

Try b = a++ and b = ++a, and you will see (of course, you'll need each function to return a value).

The difference between these two versions is only in the return value. The 'prefix++' returns the value of count before the operation, and the 'postfix++' returns the value of count after the operation.

In addition, due to its nature, the 'postfix++' can only return a copy of the variable being incremented (e.g., int), whereas the 'prefix++' can also return a reference of that variable (e.g., int&).

Since you are not returning anything in your implementation, you cannot make any use of the difference between these two versions.