C++ from the Ground Up in .NET framework

Generate Data Matrix ECC200 in .NET framework C++ from the Ground Up

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

// This program uses explicit scope resolution to select i #include <iostream> using namespace std; class base { public: int i; }; // derived1 inherits base class derived1 : public base { public: int j; }; // derived2 inherits base class derived2 : public base { public: int k; }; /* derived3 inherits both derived1 and derived2 This means that there are two copies of base in derived3! */ class derived3 : public derived1, public derived2 { public: int sum; }; int main() { derived3 ob; obderived1::i = 10; obj = 20; obk = 30; // scope resolved, use derived1's i

// scope resolved obsum = obderived1::i + obj + obk; // also resolved here cout << obderived1::i << " "; cout << obj << " " << obk << " "; cout << obsum; return 0; }

By applying the ::, the program manually selects derived1 s version 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 The answer, as you probably have guessed, is yes The solution is achieved with virtual base classes When two or more objects are derived from a common base class, you can prevent multiple copies of the base class from being present in an object derived from those classes, by declaring the base class as virtual when it is inherited To do this, you precede the name of the base class with the keyword virtual when it is inherited To illustrate this process, here is another version of the sample program This time, derived3 contains only one copy of base

// This program uses virtual base classes #include <iostream> using namespace std; class base { public: int i; }; // derived1 inherits base as virtual class derived1 : virtual public base { public: int j; }; // derived2 inherits base as virtual class derived2 : virtual public base { public: int k; }; /* derived3 inherits both derived1 and derived2 This time, there is only one copy of base class */ class derived3 : public derived1, public derived2 { public: int sum; }; int main() { derived3 ob; obi = 10; obj = 20; obk = 30; // now unambiguous

The inheritance of a base class as virtual ensures that only one copy of it will be present in any derived class

// unambiguous obsum = obi + obj + obk;

// unambiguous cout << obi << " "; cout << obj << " " << obk << " "; cout << obsum; return 0; }

As you can see, the keyword virtual precedes the rest of the inherited class specification Now that both derived1 and 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 obi = 10 is perfectly valid and unambiguous One further point to keep in mind: Even though both derived1 and derived2 specify base as virtual, base is still present in an object of either type For example, the following sequence is perfectly valid:

// Define a class of type derived1 derived1 myclass; myclassi = 88;

The difference between a normal base class and a virtual one becomes evident only 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