Virtual Base Classes

1. Virtual Base Classes By:NoufAljaffan Editedby : NoufAlmunyif

2. An element of ambiguity can be introduced into a C++ program when multiple base classes are inherited. • Consider the following incorrect program:

3. incorrect program: // This program contains an error and will not compile. #include <iostream> using namespace std; class base { public: inti; }; //derived1 inherits base. classderived1 : public base { public: intj; }; //derived2 inherits base. classderived2 : public base { public: intk; }; /* derived3 inherits both derived1 and derived2. This means that there are two copies of base in derived3! */ class derived3 :public derived1, public derived2 { public: intsum;}; intmain(){ derived3 ob; ob.i = 10;//this is ambiguous; which i??? ob.j= 20; ob.k = 30; // i ambiguous here, too ob.sum= ob.i + ob.j + ob.k; // also ambiguous, which i? cout << ob.i << « » cout << ob.j<<“ “ << ob.k <<“ “ ; cout<< ob.sum; return 0; }

4. As the comments in this program indicate • Both derivedland derived2 inherit base. • However, derived3 inherits both derivedland derived2. • As a result, there are two copies of base present in an object of type derived3, so that in an expression like • ob.i = 20; • which i is being referred to? The one in derivedlor the one in derived2? • Since there are two copies of base present in object ob, there are two ob.is! As you can see, the statement is inherently ambiguous.

5. Solution • There are two ways to remedy the preceding program • The first is to apply the scope resolution operator to i and manually select one i. • For example, the following version of the program will compile and run as expected

6. Resolve the incorrect program using 1stapproach: classbase { public: inti; }; classderived1 : public base { public: intj; }; class derived2 : public base { public: intk; }; classderived3 :public derived1, public derived2 { public: intsum;}; intmain(){ derived3 ob; ob.derived1:: i = 10; //scope resolved, uses derived1’s I ob.j = 20; ob.k = 30; // scope resolved ob.sum= ob.derived1:: i+ ob.j + ob.k; // scope resolved cout << ob.derived1:: i<< « » cout << ob.j<<“ “ << ob.k <<“ “ ; cout<< ob.sum; return 0; } By applying the ::, the program manually selects derivedl'sversion of base. However, this solution raises a deeper issue: What if only one copy of base is actually required? Is there some way to prevent two copies from being included in derived3?

7. virtual base classes • The second is to declare the base class as virtual • The solution is achieved with virtual base classes. • virtual base classes ensures that only one copy of it will be present in any derived class

8. 2’nd approach using virtual base classes // This program uses virtual base classes #include <iostream> using namespace std; class base { public: inti; }; //derived1 inherits base. classderived1 :virtualpublic base { public: intj; }; //derived2 inherits base. classderived2 : virtualpublicbase { public: intk; }; /* derived3 inherits both derived1 and derived2. This means that there is only one copy of base in derived3! */ class derived3 :public derived1, public derived2 { public: intsum;}; intmain(){ derived3 ob; ob.i= 10; //scope resolved, uses derived1’s I ob.j= 20; ob.k = 30; //unambiguous ob.sum= ob.i + ob.j + ob.k; // unambiguous cout<< ob.i<< « » cout << ob.j<<“ “ << ob.k <<“ “ ; cout<< ob.sum; return 0; } Now that both derivedland derived2 have inherited base as virtual, any multiple inheritance involving them will cause only one copy of base to be present. Therefore, in derived3 there is only one copy of base, and ob.i= 10 is perfectly valid and unambiguous.

9. difference between a normal base class and a virtual • The only difference between a normal base class and a virtual one becomes evident when an object inherits the base class more than once. • If the base class has been declared as virtual, then only one instance of it will be present in the inheriting object. Otherwise, multiple copies will be found.