virtual-inheritance

#include<iostream> using namespace std; class abc { int a; }; class xyz : public virtual abc { int b; }; int main() { abc obj; xyz obj1; cout<<endl<<sizeof(obj); cout<<endl<<sizeof(obj1); return 0; } The answers would be compiler dependent but I'm surprized when I saw this as the result ~/Documents/workspace/tmp ‹.rvm-› $ ./class_sizes 4 16 If I remove the virtual keyword then the size allocated is 4 and 8 respectively which is what I expected. Why is the extra space being taken up exactly? I suspect it is for the vptr table or something of that sorts but don't know for certain. A good article

The net is overflowing with explanations of the "dreaded diamond problem" . So is StackOverflow. I think I understand that bit, but I fail to translate that knowledge into comprehending something similar yet different. My question begins as a pure C++ question, but the answer might well branch over into MS-COM specifics. The general problem question goes: class Base { /* pure virtual stuff */ }; class Der1 : Base /* Non-virtual! */ { /* pure virtual stuff */ }; class Der2 : Base /* Non-virtual! */ { /* pure virtual stuff */ }; class Join : virtual Der1, virtual Der2 { /* implementation stuff *

class Temp { private: ~Temp() {} friend class Final; }; class Final : virtual public Temp { public: void fun() { cout<<"In base"; } }; class Derived : public Final { }; void main() { Derived obj; obj.fun(); } The above code tries to achieve non-inheritable class (final). But using above code the object of derived can still be created, why? The desired functionality is achieved only if ctor made private, my question is why it is not achievable in case of dtor private? Well, for this program (pleasse provide correct, compilable examples) #include <iostream> class Temp { private: ~Temp() {}

class Base{}; class D1:virtual public Base{}; class D2:virtual public Base{}; class DD:public D1,public D2{}; int main(){ Base *pBase=new DD; delete pBase; } This leads to crash, but I modify as below: class Base{ public: virtual ~Base(){}; }; class D1:virtual public Base{ public: virtual ~D1(){} }; class D2:virtual public Base{ public: virtual ~D2(){} }; class DD:public D1,public D2{ }; Then, it passes, but the default destructor should be the virtual dummy function, isn't it? From the C++11 specification (ISO/IEC 14882:2011(E)), section 12.4 Destructors [class.dtor]: Sub-section 4: If a

Does using virtual inheritance in C++ have a runtime penalty in compiled code, when we call a regular function member from its base class? Sample code: class A { public: void foo(void) {} }; class B : virtual public A {}; class C : virtual public A {}; class D : public B, public C {}; // ... D bar; bar.foo (); There may be, yes, if you call the member function via a pointer or reference and the compiler can't determine with absolute certainty what type of object that pointer or reference points or refers to. For example, consider: void f(B* p) { p->foo(); } void g() { D bar; f(&bar); }

while trying to analyse in greater depth inheritance mechanism of C++ I stumbled upon the following example: #include<iostream> using namespace std; class Base { public: virtual void f(){ cout << "Base.f" << endl; } }; class Left : public virtual Base { }; class Right : public virtual Base{ public: virtual void f(){ cout << "Right.f" << endl; } }; class Bottom : public Left, public Right{ }; int main(int argc,char **argv) { Bottom* b = new Bottom(); b->f(); } The above, somehow, compiles and calls Right::f(). I see what might be going on in the compiler, that it understands that there is one