In multiple inheritance, the main problem that needs to be solved is that the identifier is not unique, that is, the ambiguity problem. For example, when there are members of the same name in multiple base classes inherited by the derived class, the identifier will not be unique in the derived class. In multiple inheritance, when a derived class is derived from multiple base classes, the base classes are separated by commas, and each base class must specify the inheritance mode before, otherwise the default is private inheritance. There are three ways to solve the ambiguity problem. Use the operator "::"; Use the principle of covering with the same name; Use a virtual base class; Use the domain operator If there is no inheritance relationship between the base classes of the derived class and there is no common base class, you can distinguish the members from different base classes by adding the class name and domain operator before the member name when referring to the member with the same name. 2. Use the principle of covering with the same name Redefine the member with the same name in the base class in the derived class (if it is a member function, the parameter table must be the same, otherwise it is overloaded) to mask the members of the same name in the base class. When referencing these members of the same name, refer to Is a member of a derived class. #include Using namespace std; Class base { Public: Int x; Void show() { Cout << "Base,x= " << x << endl; } }; Class Derived :public Base { Public: Int x; Void show() { Cout << "Derived , x= " << x << endl; } }; Int main() { Derived ob; Ob.x = 5; Ob.show(); ob.Base::show(); ob.Base::x = 12; ob.Base::show(); System("pause"); Return 0; } 3. Virtual base class In multiple inheritance, when you want to refer to a member of a derived class, you first look in the scope of the derived class itself, and if you can't find it, you can find it in the base class. At this time, if these base classes have a common base class, and the derived class accesses the members of the common base class, it may be ambiguous due to the problem of the members of the same name. In this case, the virtual base class is needed to solve. #include Using namespace std; Class base { Public: Base() { x = 1; } Protected: Int x; }; Class Base1 : public Base { Public: Base1() { Cout << "Base1,x= " << x << endl; } }; Class Base2 : public Base { Public: Base2() { Cout << "Base2,x= " << x << endl; } }; Class Derived :public Base1, public Base2 { Public: Derived() { Cout << "Derived,x= " << x << endl; } }; Int main() { Derived obj; System("pause"); Return 0; } On the surface of the code, the class Base1 and the class Base2 are derived from the same base class Base, but they correspond to two different copies of the base class Base. Therefore, when the derived class Derived wants to access the variable x, it does not know which path to look for, which leads to ambiguity. The class hierarchy corresponding to the above code is shown in Figure 1, which belongs to the class hierarchy of the non-virtual base class. To solve this problem, you need to introduce a virtual base class. The specific method is to declare the public base class as a virtual base class, so that the public base class has only one copy, so that there is no ambiguity problem. The class hierarchy of the virtual base class is shown in Figure 2. figure 1 figure 2 3.1 virtual base class The declaration of the virtual base class is performed during the declaration of the derived class, and the general form of the declaration is: Class<derived class name>:virtual <derived way><base class name> This kind of derivation is called virtual inheritance. The scope and derivation of the virtual base keyword are the same as those of the general derived class, and only work for the base class that follows. After the virtual base class is declared, members of the virtual base class maintain the same memory copy along with the derived class in further derivation. #include Using namespace std; Class base { Public: Base() { x = 1; } Protected: Int x; }; Class Base1 :virtual public Base { Public: Base1() { Cout << "Base1,x= " << x << endl; } }; Class Base2 :virtual public Base { Public: Base2() { Cout << "Base2,x= " << x << endl; } }; Class Derived :public Base1, public Base2 { Public: Derived() { Cout << "Derived,x= " << x << endl; } }; Int main() { Derived obj; System("pause"); Return 0; } In the above code, since the public base class Base is declared as a virtual base class of Base1 and Base2, the class Derived derived from the class Base1 and the base class 2 has only one base class Base, which eliminates ambiguity. 3.2 virtual base class constructor and initialization The initialization of the virtual base class is syntactically the same as the initialization of the general multiple inheritance, but the execution order of the constructor is different. Mainly in the following aspects: The execution of the constructor of the virtual base class precedes the constructor of the non-virtual base class; If multiple virtual base classes are included in the same hierarchy, the constructors of these virtual base classes are executed in the order in which they are declared; If the virtual base class is derived from a non-virtual base class, the constructor of the base class is still executed first, and then the constructor of the derived class is executed. #include Using namespace std; Class base { Public: Base(int x1) { x = x1; Cout << "Base,x= " << x << endl; } Protected: Int x; }; Class Base1 :virtual public Base { Int y; Public: Base1(int x1, int y1) :Base(x1) { y = y1; Cout << "Base1 ,y=" << y << endl; } }; Class Base2 :virtual public Base { Int z; Public: Base2(int x1, int z1) :Base(x1) { z = z1; Cout << "Base2,z= " << z << endl; } }; Class Derived :public Base1, public Base2 { Int xyz; Public: Derived(int x1, int y1, int z1, int xyz1) :Base(x1), Base1(x1,y1), Base2(x1,z1) { Xyz = xyz1; Cout << "Derived,xyz = " << xyz << endl; } }; Int main() { Derived obj(1, 2, 3, 4); System("pause"); Return 0; } In the above code, the constructor of the virtual base class Base is executed only once. This is because when the derived class Derived calls the constructor of the virtual base class Base, the calls of the base base1 and Base2 to the virtual base class Base constructor are Ignore, this is the difference between initializing a virtual base class and initializing a non-virtual base class. Be careful when using virtual base classes: The virtual base class keyword virtual and the derived mode keyword public, private, protected write position does not matter, you can first write the virtual base class keyword, you can also write the derivative mode keyword first; A base class can be used as a non-virtual base class of other classes while being a virtual base class of some classes; The parameters of the virtual base class constructor must be initialized by the newly derived class, even if it is not directly inherited. SHENZHEN CHONDEKUAI TECHNOLOGY CO.LTD , https://www.szsiheyi.com
