Tính kế thừa-4

Một lớp có thể được dẫn xuất từ nhiều lớp cơ sở, sự dẫn xuất như vậy được gọi là đa kế thừa. Đa kế thừa có nghĩa là một lớp dẫn xuất kế thừa các thành viên của các lớp cơ sở khác nhau. Khả năng mạnh này khuyến khích các dạng quan trọng của việc sử dụng lại phần mềm, nhưng có thể sinh ra các vấn đề nhập nhằng.

Ví dụ 5.7: Lớp Circle và project có tên là CT5_8.PRJ (gồm các file DIRIVED.CPP, CT5_8.CPP).

File BASE1.H

BASE1.H1: //BASE1.H2: //Định nghĩa lớp Base13: #ifndef BASE1_H4: #define BASE1_H5:6: class Base17: {8: protected:9: int Value;10: public:11: Base1(int X)12: {13: Value = X;14: }15: int GetData() const16: {17: return Value;18: }19: };20:21: #endif

File BASE2.H

BASE2.H1: //BASE2.H2: //Định nghĩa lớp Base23: #ifndef BASE2_H4: #define BASE2_H5:6: class Base27: {8: protected:9: char Letter;10: public:11: Base2(char C)12: {13: Letter = C;14: }15: char GetData() const16: {17: return Letter;18: }19: };20:21: #endif

File DERIVED.H

DERIVED.H1: //DERIVED.H2: //Định nghĩa lớp Derived mà kế thừa từ nhiều lớp cơ sở (Base1 & Base2)3: #ifndef DERIVED_H4: #define DERIVED_H5: 6: #include "base1.h"7: #include "base2.h"8:9: class Derived : public Base1, public Base210: {11: private:12: float Real;13: public:14: Derived(int, char, float);15: float GetReal() const;16: friend ostream & operator <<(ostream &Output, const Derived &D);17: };18:19: #endif

File DERIVED.CPP

DERIVED.CPP1: //DERIVED.CPP2: //Định nghĩa các hàm thành viên của lớp Derived3: #include <iostream.h>4: #include "derived.h"5:6: Derived::Derived(int I, char C, float F)7: : Base1(I), Base2(C) //Gọi các constructor lớp cơ sở8: {9: Real = F;10: }11:12: float Derived::GetReal() const13: {14: return Real;15: }16:17: ostream & operator <<(ostream &Output, const Derived &D)18: {19: Output << " Integer: " << D.Value << endl20: << " Character: " << D.Letter << endl21: << "Real number: " << D.Real;22: return Output;23: }

File CT5_8.CPP

CT5_8.CPP1: //CT5_8.CPP2: //Chương trình 5.83: #include <iostream.h>4: #include "base1.h"5: #include "base2.h"6: #include "derived.h"7:8: int main()9: {10: Base1 B1(10), *Base1Ptr;11: Base2 B2('Z'), *Base2Ptr;12: Derived D(7, 'A', 3.5);13: cout << "Object B1 contains integer "14:            << B1.GetData() << endl15:            << "Object B2 contains character "16:            << B2.GetData() << endl17:            << "Object D contains:" << endl << D << endl << endl;18: cout << "Data members of Derived can be"19:            << " accessed individually:" << endl20:            << " Integer: " << D.Base1::GetData() << endl21:            << " Character: " << D.Base2::GetData() << endl22:            << "Real number: " << D.GetReal() << endl << endl;23: cout << "Derived can be treated as an "24:          << "object of either base class:" << endl;25: Base1Ptr = &D;26: cout << "Base1Ptr->GetData() yields "27:          << Base1Ptr->GetData() << endl ;28: Base2Ptr = &D;29: cout << "Base2Ptr->GetData() yields "30:            << Base2Ptr->GetData() << endl;31: return 0;32: }

Chúng ta chạy ví dụ 5.8, kết quả ở hình 5.13

Hình 5.13: Kết quả của ví dụ 5.8

Việc kế thừa nhiều lớp cơ sở tạo ra một loạt các điểm nhập nhằng trong các chương trình C++. Chẳng hạn, trong các chương trình của ví dụ 5.8, nếu thực hiện lệnh:

D.GetData();

thì trình biên dịch (Borland C++ 3.1) sẽ báo lỗi:

Member is ambiguous: ‘Base1::GetData’ and ‘Base1::GetData’

Bởi vì lớp Derived kế thừa hai hàm khác nhau có cùng tên là GetData() từ hai lớp cơ sở của nó. Base1::GetData() là hàm thành viên public của lớp cơ sở public, và nó trở thành một hàm thành viên public của Derived. Base2::GetData() là hàm thành viên public của lớp cơ sở public, và nó trở thành một hàm thành viên public của Derived. Do đó trình biên dịch không thể xác định hàm thành viên GetData() của lớp cơ sở nào để gọi thực hiện. Vì vậy, chúng ta phải sử dụng tên lớp cơ sở và toán tử định phạm vi để xác định hàm thành viên của lớp cơ sở lúc gọi hàm GetData().

Cú pháp của một lớp kế thừa nhiều lớp cơ sở:

class <drived_class_name> : <type_of_inheritance> <base_class_name1> ,

<type_of_inheritance> <base_class_name2>, …

{

………………..

};

Trình tự thực hiện constructor trong đa kế thừa: constructor lớp cở sở xuất hiện trước sẽ thực hiện trước và cuối cùng mới tới constructor lớp dẫn xuất. Đối với destructor có trình tự thực hiện theo thứ tự ngược lại.

Chúng ta không thể khai báo hai lần cùng một lớp trong danh sách của các lớp cơ sở cho một lớp dẫn xuất. Tuy nhiên vẫn có thể có trường hợp cùng một lớp cơ sở được đề cập nhiều hơn một lần trong các lớp tổ tiên của một lớp dẫn xuất. Điều này phát sinh lỗi vì không có cách nào để phân biệt hai lớp cơ sở gốc.

Ví dụ 5.9:

CT5_9.CPP1: //Chương trình 5.92: #include <iostream.h>3: class A4: {5: public:6: int X1;7: };8:9: class B : public A10: {11: public:12: float X2;13: };14:15: class C : public A16: {17: public:18: double X3;19: };20:21: class D : public B,public C22: {23: public:24: char X4;25: };26:27: int main()28: {29: D Obj;30: Obj.X2=3.14159F;31: Obj.X1=0; //Nhập nhằng32: Obj.X4='a';33: Obj.X3=1.5;34: cout<<"X1="<<Obj.X1<<endl; //Nhập nhằng35: cout<<"X2="<<Obj.X2<<endl;36: cout<<"X3="<<Obj.X3<<endl;37: cout<<"X4="<<Obj.X4<<endl;38: return 0;39: }

Khi biên dịch chương trình ở ví dụ 5.9, trình biên dịch sẽ báo lỗi ở dòng 31 và 34:

Member is ambiguous: ‘A::X1’ and ‘A::X1’

Hình 5.14

Ở đây chúng ta thấy có hai lớp cở sở A cho lớp D, và trình biên dịch không thể nào nhận biết được việc truy cập X1 được kế thừa thông qua B hoặc truy cập X1 được kế thừa thông qua C. Để khắc phục điều này, chúng ta chỉ định một cách tường minh trong lớp D như sau:

Obj.C::X1=0;

Tuy nhiên, đây cũng chỉ là giải pháp có tính chấp vá, bởi thực chất X1 nào trong trường hợp nào cũng được. Giải pháp cho vấn đề này là khai báo A như lớp cơ sở kiểu virtual cho cả B và C. Khi đó chương trình ở ví dụ 5.9 được viết lại như sau:

Ví dụ 5.10:

CT5_10.CPP1: //Chương trình 5.102: #include <iostream.h>3: class A4: {5: public:6: int X1;7: };8:9: class B : virtual public A10: {11: public:12: float X2;13: };14:15: class C : virtual public A16: {17: public:18: double X3;19: };20:21: class D : public B,public C22: {23: public:24: char X4;25: };26:27: int main()28: {29: D Obj;30: Obj.X2=3.14159F;31: Obj.X1=0; //OK32: Obj.X4='a';33: Obj.X3=1.5;34: cout<<"X1="<<Obj.X1<<endl; //OK35: cout<<"X2="<<Obj.X2<<endl;36: cout<<"X3="<<Obj.X3<<endl;37: cout<<"X4="<<Obj.X4<<endl;38: return 0;39: }

Chúng ta chạy ví dụ 5.10, kết quả ở hình 5.15

Hình 5.15: Kết quả của ví dụ 5.10

Các lớp cơ sở kiểu virtual,có cùng một kiểu lớp, sẽ được kết hợp để tạo một lớp cơ sở duy nhất có kiểu đó cho bất kỳ lớp dẫn xuất nào kế thừa chúng. Hai lớp cơ sở A ở trên bất giờ sẽ trở thành một lớp cơ sở A duy nhất cho bất kỳ lớp dẫn xuất nào từ B và C. Điều này có nghĩa là D chỉ có một cơ sở của lớp A, vì vậy tránh được sự nhập nhằng.