cpp.cpp: virtual inheritance added

Author: cirosantilli

c/cpp.cpp

@@ -1224,13 +1224,50 @@ void printCallStack()
     class PureVirtualImplementedOtherBase
     {
         public:
-
-            void pureVirtualImplementedOtherBase()
+            void pureVirtual()
+            {
+                callStack.push_back("PureVirtualImplementedOtherBase::pureVirtual()");
+            }
+        private:
+            void privatePureVirtual()
             {
-                callStack.push_back("PureVirtualImplementedOtherBase::pureVirtualOtherBase()");
+                callStack.push_back("PureVirtualImplementedOtherBase::privatePureVirtual()");
             }
     };
 
+    class DerivedAbtractAndImplementator : BaseAbstract, PureVirtualImplementedOtherBase
+    {
+        //public:
+            //void pureVirtual()
+            //{
+                //callStack.push_back("PureVirtualImplementedOtherBase::pureVirtual()");
+            //}
+        //private:
+            //void privatePureVirtual()
+            //{
+                //callStack.push_back("PureVirtualImplementedOtherBase::privatePureVirtual()");
+            //}
+    };
+
+    class MultipleInheritanceConflictBase1 {
+        public:
+            const static int is = 1;
+            int i;
+            void f(){}
+    };
+
+    class MultipleInheritanceConflictBase2 {
+        public:
+            const static int is = 2;
+            int i;
+            void f(){}
+    };
+
+    class MultipleInheritanceConflictDerived :
+        MultipleInheritanceConflictBase1,
+        MultipleInheritanceConflictBase2
+        {};
+
     class BaseProtected
     {
         public:
@@ -1258,8 +1295,7 @@ void printCallStack()
         //public Derived,   //WARN cannot use BasePrivate inside: ambiguous
         protected BaseProtected,
         private BasePrivate,
-        public BaseAbstract,
-        public PureVirtualImplementedOtherBase
+        public BaseAbstract
     {
         public:
 
@@ -6038,163 +6074,197 @@ int main(int argc, char **argv)
             }
         }
 
-        //#overridding
+        /*
+        #inheritance
+        */
         {
-            Class c;
-            Class* cp = &c;
+            //#overridding
+            {
+                Class c;
+                Class* cp = &c;
 
-            c.i = 0;
-            c.Class::i = 0;
-            cp->Class::i = 0;
-            c.Base::i = 1;
-            c.BaseAbstract::i = 2;
+                c.i = 0;
+                c.Class::i = 0;
+                cp->Class::i = 0;
+                c.Base::i = 1;
+                c.BaseAbstract::i = 2;
 
-            assert(c.i          == 0);
-            assert(c.Class::i   == 0);
-            assert(cp->Class::i == 0);
+                assert(c.i          == 0);
+                assert(c.Class::i   == 0);
+                assert(cp->Class::i == 0);
 
-            assert(c.Base::i   == 1);
-            assert(cp->Base::i == 1);
+                assert(c.Base::i   == 1);
+                assert(cp->Base::i == 1);
 
-            assert(c.BaseAbstract::i   == 2);
-            assert(cp->BaseAbstract::i == 2);
+                assert(c.BaseAbstract::i   == 2);
+                assert(cp->BaseAbstract::i == 2);
 
-            //c.iAmbiguous = 0;
-                //ERROR ambiguous
-            c.Base::iAmbiguous = 0;
-            c.BaseAbstract::iAmbiguous = 0;
+                //c.iAmbiguous = 0;
+                    //ERROR ambiguous
+                c.Base::iAmbiguous = 0;
+                c.BaseAbstract::iAmbiguous = 0;
 
-            callStack.clear();
-            c.method();
-            assert(callStack.back() == "Class::method()");
-            //c.methodAmbiguous();
-                //ERROR ambiguous
-            callStack.clear();
-            c.Base::methodAmbiguous();
-            assert(callStack.back() == "Base::methodAmbiguous()");
+                callStack.clear();
+                c.method();
+                assert(callStack.back() == "Class::method()");
+                //c.methodAmbiguous();
+                    //ERROR ambiguous
+                callStack.clear();
+                c.Base::methodAmbiguous();
+                assert(callStack.back() == "Base::methodAmbiguous()");
 
-            callStack.clear();
-            c.BaseAbstract::methodAmbiguous();
-            assert(callStack.back() == "BaseAbstract::methodAmbiguous()");
+                callStack.clear();
+                c.BaseAbstract::methodAmbiguous();
+                assert(callStack.back() == "BaseAbstract::methodAmbiguous()");
+            }
 
             /*
-            #virtual inheritance
+            #virtual
 
-                <http://en.wikipedia.org/wiki/Virtual_inheritance>
+                Virtual: decides on runtime based on object type.
 
-                TODO
-            */
-        }
+                <http://stackoverflow.com/questions/2391679/can-someone-explain-c-virtual-methods>
 
-        /*
-        #virtual
+            #pure virtual function
+
+                Cannot instantiate this class
+
+                Can only instantiate derived classes that implement this.
+
+                If a class has a pure virtual method is called as an *abstract class* or *interface*.
+
+                In Java there is a language difference between those two terms,
+                and it might be a good idea to differentiate them when speaking about C++:
 
-            Virtual: decides on runtime based on object type.
+                - interface: no data
+                - abstract: data
 
-            <http://stackoverflow.com/questions/2391679/can-someone-explain-c-virtual-methods>
+            #polymorphism
 
-        #pure virtual function
+                - loop an array of several dereived classes
+                - call a single base class method
+                - uses the correct derived override
 
-            Cannot instantiate this class
+                Implementation: *vtable* is used to implement this.
 
-            Can only instantiate derived classes that implement this.
+            #vtable
 
-            If a class has a pure virtual method is called as an *abstract class* or *interface*.
+                <http://en.wikipedia.org/wiki/Virtual_method_table>
 
-            In Java there is a language difference between those two terms,
-            and it might be a good idea to differentiate them when speaking about C++:
+                Whenever you create a pointer to a class with a virtual method,
+                that pointer points to a pointer that identifies the class type,
+                and points to the correct method.
 
-            - interface: no data
-            - abstract: data
+                Consequence: every call to a virtual methods means:
 
-        #polymorphism
+                - an extra pointer dereference
+                - an extra pointer stored in memory
 
-            - loop an array of several dereived classes
-            - call a single base class method
-            - uses the correct derived override
+                Also virtual functions cannot be inlined.
 
-            Implementation: *vtable* is used to implement this.
+            #Static interfaces
 
-        #vtable
+                It is possible to assert that interfaces are implemented without dynamic vtable overhead via CRTP:
 
-            <http://en.wikipedia.org/wiki/Virtual_method_table>
+                - <http://stackoverflow.com/questions/2587541/does-c-have-a-static-polymorphism-implementation-of-interface-that-does-not-us>
 
-            Whenever you create a pointer to a class with a virtual method,
-            that pointer points to a pointer that identifies the class type,
-            and points to the correct method.
+                - <http://en.wikipedia.org/wiki/Template_metaprogramming#Static_polymorphism>
 
-            Consequence: every call to a virtual methods means:
+            #CRTP
 
-            - an extra pointer dereference
-            - an extra pointer stored in memory
+                Curiously recurring template pattern.
 
-            Also virtual functions cannot be inlined.
+                <http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern#Static_polymorphism>
+            */
+            {
+                //BaseAbstract b;
+                    //ERROR: BaseAbstract cannot be instantiated because it contains a pure virtual method
+                    //virtual = 0;. That method must be implemented on derived classes
 
-        #Static interfaces
+                //even if you can't instantiate base, you can have pointers to it
+                {
+                    BaseAbstract* bap = new Class;
+                    //BaseAbstract* bap = &c;
+                        //SAME
 
-            It is possible to assert that interfaces are implemented without dynamic vtable overhead via CRTP:
+                    callStack.clear();
+                    bap->method();
+                    assert(callStack.back() == "BaseAbstract::method()");
+                        //base method because non-virtual
 
-            - <http://stackoverflow.com/questions/2587541/does-c-have-a-static-polymorphism-implementation-of-interface-that-does-not-us>
+                    callStack.clear();
+                    bap->virtualMethod();
+                    assert(callStack.back() == "Class::virtualMethod()");
+                        //class method because virtual
 
-            - <http://en.wikipedia.org/wiki/Template_metaprogramming#Static_polymorphism>
+                    delete bap;
+                }
 
-        #CRTP
+                {
+                    //you can also have BaseAbstract&
+                    Class c;
+                    BaseAbstract& ba = c;
 
-            Curiously recurring template pattern.
+                    callStack.clear();
+                    ba.method();
+                    assert(callStack.back() == "BaseAbstract::method()");
 
-            <http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern#Static_polymorphism>
-        */
-        {
-            //BaseAbstract b;
-                //ERROR: BaseAbstract cannot be instantiated because it contains a pure virtual method
-                //virtual = 0;. That method must be implemented on derived classes
+                    callStack.clear();
+                    ba.virtualMethod();
+                    assert(callStack.back() == "Class::virtualMethod()");
+                }
 
-            //even if you can't instantiate base, you can have pointers to it
-            {
-                BaseAbstract* bap = new Class;
-                //BaseAbstract* bap = &c;
-                    //SAME
+                {
+                    Class c = Class();
+                    Base* bp = &c;
+                    bp = bp->covariantReturn();
 
-                callStack.clear();
-                bap->method();
-                assert(callStack.back() == "BaseAbstract::method()");
-                    //base method because non-virtual
+                    callStack.clear();
+                    bp->virtualMethod();
+                    assert(callStack.back() == "Class::virtualMethod()");
 
-                callStack.clear();
-                bap->virtualMethod();
-                assert(callStack.back() == "Class::virtualMethod()");
-                    //class method because virtual
+                    //classPtr = basePtr->covariantReturn();
+                        //ERROR
+                        //conversion from Base to Class
+                }
 
-                delete bap;
+                /*
+                It is not possibleto implement pure virtual methods on another base class:
+                they must be implemented on the Derived class.
+                */
+                {
+                    //DerivedAbtractAndImplementator d; //ERROR
+                }
             }
 
-            {
-                //you can also have BaseAbstract&
-                Class c;
-                BaseAbstract& ba = c;
+            /*
+            #multiple inheritance
 
-                callStack.clear();
-                ba.method();
-                assert(callStack.back() == "BaseAbstract::method()");
+                In C++, if a member of an object or static variable of a class
+                comes from two base classes, an ambiguity occurs and the program does not
+                compile.
 
-                callStack.clear();
-                ba.virtualMethod();
-                assert(callStack.back() == "Class::virtualMethod()");
+                This just makes multiple inheritance very insane, since the addition of
+                new fields in a Base class can break existing code on Derived classes.
+            */
+            {
+                //MultipleInheritanceConflictDerived::is;
+                //MultipleInheritanceConflictDerived().i;
+                //MultipleInheritanceConflictDerived().f();
             }
 
-            {
-                Class c = Class();
-                Base* bp = &c;
-                bp = bp->covariantReturn();
+            /*
+            #dreaded diamond
 
-                callStack.clear();
-                bp->virtualMethod();
-                assert(callStack.back() == "Class::virtualMethod()");
+            #virtual inheritance
 
-                //classPtr = basePtr->covariantReturn();
-                    //ERROR
-                    //conversion from Base to Class
-            }
+                Solves the dreaded diamond problem.
+
+                Has nothing to do with the `virtual` keyword for methods:
+                everything is done at compile time in thie usage.
+
+                <http://stackoverflow.com/questions/21558/in-c-what-is-a-virtual-base-class>
+            */
         }
 
         //#friend