Skip to content Skip to navigation

OpenStax_CNX

You are here: Home » Content » Kế thừa

Navigation

Lenses

What is a lens?

Definition of a lens

Lenses

A lens is a custom view of the content in the repository. You can think of it as a fancy kind of list that will let you see content through the eyes of organizations and people you trust.

What is in a lens?

Lens makers point to materials (modules and collections), creating a guide that includes their own comments and descriptive tags about the content.

Who can create a lens?

Any individual member, a community, or a respected organization.

What are tags? tag icon

Tags are descriptors added by lens makers to help label content, attaching a vocabulary that is meaningful in the context of the lens.

This content is ...

Affiliated with (What does "Affiliated with" mean?)

This content is either by members of the organizations listed or about topics related to the organizations listed. Click each link to see a list of all content affiliated with the organization.
  • VOCW

    This module is included inLens: Vietnam OpenCourseWare's Lens
    By: Vietnam OpenCourseWare

    Click the "VOCW" link to see all content affiliated with them.

Recently Viewed

This feature requires Javascript to be enabled.
 

Kế thừa

Module by: Lê Thị Mỹ Hạnh. E-mail the author

Summary: Phần này trình bày về kế thừa

DẪN NHẬP

Trong chương này và chương kế, chúng ta tìm hiểu hai khả năng mà lập trình hướng đối tượng cung cấp là tính kế thừa (inheritance) và tính đa hình (polymorphism). Tính kế thừa là một hình thức của việc sử dụng lại phần mềm trong đó các lớp mới được tạo từ các lớp đã có bằng cách "hút" các thuộc tính và hành vi của chúng và tô điểm thêm với các khả năng mà các lớp mới đòi hỏi. Việc sử dụng lại phần mềm tiết kiệm thời gian trong việc phát triển chương trình. Nó khuyến khích sử dụng lại phần mềm chất lượng cao đã thử thách và gỡ lỗi, vì thế giảm thiểu các vấn đề sau khi một hệ trở thành chính thức. Tính đa hình cho phép chúng ta viết các chương trình trong một kiểu cách chung để xử lý các lớp có liên hệ nhau. Tính kế thừa và tính đa hình các kỹ thuật có hiệu lực đối với sự chia với sự phức tạp của phần mềm.

Khi tạo một lớp mới, thay vì viết các thành viên dữ liệu và các hàm thành viên, lập trình viên có thể thiết kế mà lớp mới được kế thừa các thành viên dữ liệu và các hàm thành viên của lớp trước định nghĩa là lớp cơ sở (base class). Lớp mới được tham chiếu là lớp dẫn xuất (derived class). Mỗi lớp dẫn xuất tự nó trở thành một ứng cử là một lớp cơ sở cho lớp dẫn xuất tương lai nào đó.

Bình thường một lớp dẫn xuất thêm các thành viên dữ liệu và các hàm thành viên, vì thế một lớp dẫn xuất thông thường rộng hơn lớp cơ sở của nó. Một lớp dẫn xuất được chỉ định hơn một lớp cơ sở và biểu diễn một nhóm của các đối tượng nhỏ hơn. Với đối tượng đơn, lớp dẫn xuất, lớp dẫn xuất bắt đầu bên ngoài thực chất giống như lớp cơ sở. Sức mạnh thực sự của sự kế thừa là khả năng định nghĩa trong lớp dẫn xuất các phần thêm, thay thế hoặc tinh lọc các đặc tính kế thừa từ lớp cơ sở.

Mỗi đối tượng của một lớp dẫn xuất cũng là một đối tượng của lớp cơ sở của lớp dẫn xuất đó. Tuy nhiên điều ngược lại không đúng, các đối tượng lớp cơ sở không là các đối tượng của các lớp dẫn xuất của lớp cơ sở đó. Chúng ta sẽ lấy mối quan hệ "đối tượng lớp dẫn xuất là một đối tượng lớp cơ sở" để thực hiện các thao tác quan trọng nào đó. Chẳng hạn, chúng ta có thể luồn một sự đa dạng của các đối tượng khác nhau có liên quan thông qua sư kế thừa thành danh sách liên kết của các đối tượng lớp cơ sở. Điều này cho phép sự đa dạng của các đối tượng để xử lý một cách tổng quát.

Chúng ta phân biệt giữa "là một" (is a) quan hệ và "có một" (has a) quan hệ. "là một" là sự kế thừa. Trong một "là một" quan hệ, một đối tượng của kiểu lớp dẫn xuất cũng có thể được xử lý như một đối tượng của kiểu lớp cơ sở. "có một" là sự phức hợp (composition). Trong một "có một" quan hệ, một đối tượng lớp có một hay nhiều đối tượng của các lớp khác như là các thành viên, do đó lớp bao các đối tượng này gọi là lớp phức hợp (composed class).

KẾ THỪA ĐƠN

Các lớp cơ sở và các lớp dẫn xuất

Thường một đối tượng của một lớp thật sự là một đối tượng của lớp khác cũng được. Một hình chữ nhật là một tứ giác, vì thế lớp Rectangle có thể kế thừa từ lớp Quadrilateral. Trong khung cảnh này, lớp Quadrilateral gọi là một lớp cơ sở và lớp Rectangle gọi là một lớp dẫn xuất. Hình 5.1 cho chúng ta một vài ví dụ về kế thừa đơn.

Các ngôn ngữ lập trình hướng đối tượng như SMALLTALK sử dụng thuật ngữ khác: Trong kế thừa, lớp cơ sở được gọi là lớp cha (superclass), lớp dẫn xuất được gọi là lớp con (subclass).

Bảng 1
Lớp cơ sở Lớp dẫn xuất
Student
GraduateStudent
UndergraduateStudent
Shape
Circle
Triangle
Rectangle
Loan
CarLoan
HomeImprovementLoan
MortgageLoan
Employee
FacultyMember
StaffMember
Acount
CheckingAcount
SavingsAcount

Hình 5.1: Một vài kế thừa đơn.

Sự kế thừa hình thành các cấu trúc phân cấp giống cây (còn gọi là cây phả hệ). Một lớp cơ sở tồn tại trong một phân cấp quan hệ với lớp dẫn xuất của nó. Một lớp có thể tồn tại chắc chắn bởi chính nó, nhưng khi một lớp được sử dụng với cơ chế của sự kế thừa thì lớp trở thành hoặc là một lớp cơ sở mà cung cấp các thuộc tính và các hành vi cho các lớp khác, hoặc là lớp trở thành một lớp dẫn xuất mà kế thừa các thuộc tính và các hành vi.

Chúng ta phát triển một phân cấp kế thừa đơn. Một trường đại học cộng đồng đặc thù có hàng ngàn người mà là các thành viên cộng đồng. Những người này gồm các người làm công và các sinh viên. Những người làm công hoặc là các thành viên khoa hoặc các thành viên nhân viên. Các thành viên khoa hoặc là các nhà quản lý hoặc giảng viên. Điều này trở thành phân cấp kế thừa như hình 5.2

Hình 1
Hình 1 (graphics1.png)

Hình 5.2: Một phân cấp kế thừa cho các thành viên của trường đại học cộng đồng.

Phân cấp kế thừa quan trọng khác là phân cấp Shape ở hình 5.3.

Hình 2
Hình 2 (graphics2.png)

Hình 5.3: Phân cấp lớp Shape

Để chỉ định lớp CommissionWorker được dẫn xuất từ lớp Employee, lớp CommissionWorker được định nghĩa như sau:

class CommissionWorker: public Employee

{………….

};

Điều này được gọi là kế thừa public và là loại mà phần lớn được sử dụng. Ngoài ra chúng ta còn có kế thừa private và kế thừa protected. Với kế thừa public, các thành viên public và protected của lớp cơ sở được kế thừa như là các thành viên public và protected của lớp dẫn xuất tương ứng. Nên nhớ rằng các thành viên private của lớp cơ sở không thể truy cập từ các lớp dẫn xuất của lớp đó.

Xử lý các đối tượng lớp cơ sở và các đối tượng lớp dẫn xuất tương tự; phổ biến là được biểu diễn bằng các thuộc tính và các hành vi của lớp cơ sở. Các đối tượng của bất kỳ lớp nào dẫn xuất từ một lớp cơ sở chung có thể tất cả được xử lý như các đối tượng của lớp cơ sở đó.

Các thành viên protected

Các thành viên public của một lớp cơ sở được truy cập bởi tất cả các hàm trong chương trình. Các thành viên private của một lớp cơ sở chỉ được truy cập bởi các hàm thành viên và các hàm friend của lớp cơ sở.

Truy cập protected phục vụ như một mức trung gian của sự bảo vệ giữa truy cập public và truy cập private. Các thành viên protected của một lớp cơ sở có thể chỉ được truy cập bởi các hàm thành viên và các hàm friend của lớp cơ sở và bởi các hàm thành viên và các hàm friend của lớp dẫn xuất.

Các thành viên lớp dẫn xuất kế thừa public có thể tham khảo tới các thành viên public và protected bằng cách sử dụng các tên thành viên.

Ép kiểu các con trỏ lớp cơ sở tới các con trỏ lớp dẫn xuất

Một đối tượng của một lớp dẫn xuất kế thừa public cũng có thể được xử lý như một đối tượng của lớp cơ sở của nó tương ứng. Nhưng ngược lại không đúng: một đối tượng lớp cơ sở cũng không tự động là một đối tượng lớp dẫn xuất.

Tuy nhiên, có thể sử dụng ép kiểu để chuyển đổi một con trỏ lớp cơ sở thành một con trỏ lớp dẫn xuất.

Ví dụ 5.1: Chương trình sau sẽ được chia thành nhiều file (gồm các file .H và .CPP) và tạo một project có tên là CT5_1.PRJ gồm các file .cpp

graphics3.pngFile POINT.H:

1: //POINT.H

2: //Định nghĩa lớp Point

3: #ifndef POINT_H

4: #define POINT_H

5:

6: class Point

7: {

8: protected:

9: float X,Y;

10: public:

11: Point(float A= 0, float B= 0);

12: void SetPoint(float A, float B);

13: float GetX() const

14: {

15: return X;

16: }

17: float GetY() const

18: {

19: return Y;

20: }

21: friend ostream & operator <<(ostream &Output, const Point &P);

22: };

23:

24: #endif

Hình 3
Hình 3 (graphics4.png)
File POINT.CPP

1: //POINT.CPP

2: //Định nghĩa các hàm thành viên của lớp Point

3: #include <iostream.h>

4: #include "point.h"

5:

6: Point::Point(float A, float B)

7: {

8: SetPoint(A, B);

9: }

10:

11: void Point::SetPoint(float A, float B)

12: {

13: X = A;

14: Y = B;

15: }

16:

17: ostream & operator <<(ostream &Output, const Point &P)

18: {

19: Output << '[' << P.X << ", " << P.Y << ']';

20: return Output;

21: }

Hình 4
Hình 4 (graphics5.png)
File CIRCLE.H

1: //CIRCLE.H

2: //Định nghĩa lớp Circle

3: #ifndef CIRCLE_H

4: #define CIRCLE_H

5:

6: #include "point.h"

7: class Circle : public Point

8: {

9: protected:

10: float Radius;

11: public:

12: Circle(float R = 0.0, float A = 0, float B = 0);

13: void SetRadius(float R);

14: float GetRadius() const;

15: float Area() const;

16: friend ostream & operator <<(ostream &Output, const Circle &C);

17: };

18:

19: #endif

Hình 5
Hình 5 (graphics6.png)
File CIRCLE.CPP

1: //CIRCLE.CPP

2: //Định nghĩa các hàm thành viên của lớp Circle

3: #include <iostream.h>

4: #include <iomanip.h>

5: #include "circle.h"

6:

7: Circle::Circle(float R, float A, float B): Point(A, B)

8: {

9: Radius = R;

10: }

11:

12: void Circle::SetRadius(float R)

13: {

14: Radius = R;

15: }

16:

17: float Circle::GetRadius() const

18: {

19: return Radius;

20: }

21:

22: float Circle::Area() const

23: {

24: return 3.14159 * Radius * Radius;

25: }

26:

27: //Xuất một Circle theo dạng: Center = [x, y]; Radius = #.##

28: ostream & operator <<(ostream &Output, const Circle &C)

29: {

30: Output << "Center = [" << C.X << ", " << C.Y

31: << "]; Radius = " << setiosflags(ios::showpoint)

32: << setprecision(2) << C.Radius;

33: return Output;

34: }

Hình 6
Hình 6 (graphics7.png)
File CT5_1.CPP:

1: //CT5_1.CPP

2: //Chương trình 5.1: Ép các con trỏ lớp cơ sở tới các con trỏ lớp dẫn xuất

3: #include <iostream.h>

4: #include <iomanip.h>

5: #include "point.h"

6: #include "circle.h"

7:

8: int main()

9: {

10: Point *PointPtr, P(3.5, 5.3);

11: Circle *CirclePtr, C(2.7, 1.2, 8.9);

12: cout << "Point P: "<<P<<endl<<"Circle C: "<<C<< endl;

13 //Xử lý một Circle như một Point (chỉ xem một phần lớp cơ sở)

14: PointPtr = &C;

15: cout << endl << "Circle C (via *PointPtr): "<<*PointPtr<<endl;

16 //Xử lý một Circle như một Circle

17: PointPtr = &C;

18: CirclePtr = (Circle *) PointPtr;

19: cout << endl << "Circle C (via *CirclePtr): " << endl

20:            <<*CirclePtr<< endl << "Area of C (via CirclePtr): "

21:            << CirclePtr->Area() << endl;

22: //Nguy hiểm: Xem một Point như một Circle

23: PointPtr = &P;

24: CirclePtr = (Circle *) PointPtr;

25: cout << endl << "Point P (via *CirclePtr): "<< endl

26:            <<*CirclePtr<< endl << "Area of object CirclePtr points to: "

27:            <<CirclePtr->Area() << endl;

28: return 0;

29: }

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

Hình 7
Hình 7 (graphics8.png)

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

Trong định nghĩa lớp Point, các thành viên dữ liệu X và Y được chỉ định là protected, điều này cho phép các lớp dẫn xuất từ lớp Point truy cập trực tiếp các thành viên dữ liệu kế thừa. Nếu các thành viên dữ liệu này được chỉ định là private, các hàm thành viên public của Point phải được sử dụng để truy cập dữ liệu, ngay cả bởi các lớp dẫn xuất.

Lớp Circle được kế thừa từ lớp Point với kế thừa public (ở dòng 7 file CIRCLE.H), tất cả các thành viên của lớp Point được kế thừa thành lớp Circle. Điều này có nghĩa là giao diện public bao gồm các hàm thành viên public của Point cũng như các hàm thành viên Area(), SetRadius() và GetRadius().

Constructor lớp Circle phải bao gồm constructor lớp Point để khởi động phần lớp cơ sở của đối tượng lớp Circle ở dòng 7 file CIRCLE.CPP, dòng này có thể được viết lại như sau:

Circle::Circle(float R, float A, float B)

: Point(A, B) //Gọi constructor của lớp cơ sở

Các giá trị A và B được chuyển từ constructor lớp Circle tới constructor lớp Point để khởi động các thành viên X và Y của lớp cơ sở. Nếu constructor lớp Circle không bao gồm constructor lớp Point thì constructor lớp Point gọi với các giá trị mặc định cho X và Y (nghĩa là 0 và 0). Nếu lớp Point không cung cấp một constructor mặc định thì trình biên dịch phát sinh lỗi.

Trong chương trình chính (file CT5_1.CPP) gán một con trỏ lớp dẫn xuất (địa chỉ của đối tượng C) cho con trỏ lớp cơ sở PointPtr và xuất đối tượng C của Circle bằng toán tử chèn dòng của lớp Point (ở dòng 14 và 15). Chú ý rằng chỉ phần Point của đối tượng C của Circle được hiển thị. Nó luôn luôn đúng để gán một con trỏ lớp dẫn xuất cho con trỏ lớp cơ sở bởi vì một đối tượng lớp dẫn xuất là một đối tượng lớp cơ sở. Con trỏ lớp cơ sở chỉ trông thấy phần lớp cơ sở của đối tượng lớp dẫn xuất. Trình biên dịch thực hiện một chuyển đổi ngầm của con trỏ lớp dẫn xuất cho một con trỏ lớp cơ sở.

Sau đó chương trình gán một con trỏ lớp dẫn xuất (địa chỉ của đối tượng C) cho con trỏ lớp cơ sở PointPtr và ép PointPtr trở về kiểu Circle *. Kết quả của ép kiểu được gán cho CirclePtr. Đối tượng C của Circle được xuất bằng cách sử dụng toán tử chèn dòng của Circle. Diện tích của đối tượng C được xuất thông qua CirclePtr. Các kết quả này là giá trị diện tích đúng bởi vì các con trỏ luôn luôn được trỏ tới một đối tượng Circle (từ dòng 17 đến 22).

Kế tiếp, chương trình gán một con trỏ lớp cơ sở (địa chỉ của đối tượng P) cho con trỏ lớp cơ sở PointPtr và ép PointPtr trở về kiểu Circle *. Kết quả của ép kiểu được gán cho CirclePtr. Đối tượng P được xuất sử dụng toán tử chèn dòng của lớp Circle. Chú ý rằng giá trị xuất của thành viên Radius "kỳ lạ". Việc xuất một Point như một Circle đưa đến một giá trị không hợp lệ cho Radius bởi vì các con trỏ luôn được trỏ đến một đối tượng Point. Một đối tượng Point không có một thành viên Radius. Vì thế, chương trình xuất giá trị "rác" đối với thành viên dữ liệu Radius. Chú ý rằng giá trị của diện tích là 0.0 bởi vì tính toàn này dựa trên giá trị không tồn tại của Radius (từ dòng 23 đến 27).Rõ ràng, truy cập các thành viên dữ liệu mà không phải ở đó thì nguy hiểm. Gọi các hàm thành viên mà không tồn tại có thể phá hủy chương trình.

Định nghĩa lại các thành viên lớp cơ sở trong một lớp dẫn xuất

Một lớp dẫn xuất có thể định nghĩa lại một hàm thành viên lớp cơ sở. Điều này được gọi là overriding. Khi hàm đó được đề cập bởi tên trong lớp dẫn xuất, phiên bản của lớp dẫn xuất được chọn một cách tự động. Toán tử định phạm vi có thể sử dụng để truy cập phiên bản của lớp cơ sở từ lớp dẫn xuất.

Các lớp cơ sở public, protected và private

Khi dẫn xuất một lớp từ một lớp cơ sở, lớp cơ sở có thể được kế thừa là public, protected và private.

class <drived_class_name> : <type_of_inheritance> <base_class_name>

{………………..

};

Trong đó type_of_inheritance là public, protected hoặc private. Mặc định là private.

Khi dẫn xuất một lớp từ một lớp cơ sở public, các thành viên public của lớp cơ sở trở thành các thành viên public của lớp dẫn xuất, và các thành viên protected của lớp cơ sở trở thành các thành viên protected của lớp dẫn xuất. Các thành viên private của lớp cơ sở không bao giờ được truy cập trực tiếp từ một lớp dẫn xuất.

Khi dẫn xuất một lớp từ một lớp cơ sở protected, các thành viên public và protected của lớp cơ sở trở thành các thành viên protected của lớp dẫn xuất. Khi dẫn xuất một lớp từ một lớp cơ sở private, các thành viên public và protected của lớp cơ sở trở thành các thành viên private của lớp dẫn xuất.

Bảng sau (hình 5.6)tổng kết khả năng truy cập các thành viên lớp cơ sở trong một lớp dẫn xuất dựa trên thuộc tính xác định truy cập thành viên của các thành viên trong lớp cơ sở và kiểu kế thừa.

Bảng 2
Kiểu kế thừa  
Kế thừa public Kế thừa protected Kế thừa private  
public public trong lớp dẫn xuất.Có thể truy cập trực tiếp bởi các hàm thành viên không tĩnh, các hàm friend và các hàm không thành viên. protected trong lớp dẫn xuất.Có thể truy cập trực tiếp bởi các hàm thành viên không tĩnh, các hàm friend. private trong lớp dẫn xuất.Có thể truy cập trực tiếp bởi các hàm thành viên không tĩnh, các hàm friend.
protected protected trong lớp dẫn xuất.Có thể truy cập trực tiếp bởi các hàm thành viên không tĩnh, các hàm friend. protected trong lớp dẫn xuất.Có thể truy cập trực tiếp bởi các hàm thành viên không tĩnh, các hàm friend. private trong lớp dẫn xuất.Có thể truy cập trực tiếp bởi các hàm thành viên không tĩnh, các hàm friend.
private Dấu trong lớp dẫn xuất.Có thể truy cập trực tiếp bởi các hàm thành viên không tĩnh, các hàm friend thông qua các hàm thành viên public và protected của lớp cơ sở. Dấu trong lớp dẫn xuất.Có thể truy cập trực tiếp bởi các hàm thành viên không tĩnh, các hàm friend thông qua các hàm thành viên public và protected của lớp cơ sở. Dấu trong lớp dẫn xuất.Có thể truy cập trực tiếp bởi các hàm thành viên không tĩnh, các hàm friend thông qua các hàm thành viên public và protected của lớp cơ sở.

Hình 5.7: Tổng kết khả năng truy cập thành viên lớp cơ sở trong lớp dẫn xuất.

Các contructor và destructor lớp dẫn xuất

Bởi vì một lớp dẫn xuất kết thừa các thành viên lớp cơ sở của nó (ngoại trừ constructor và destructor), khi một đối tượng của lớp dẫn xuất được khởi động, constructor lớp cơ sở phải được gọi để khởi động các thành viên lớp cơ sở của đối tượng lớp dẫn xuất. Một bộ khởi tạo lớp cơ sở (sử dụng cú pháp giống như bộ khởi tạo thành viên) có thể được cung cấp trong constructor lớp dẫn xuất để gọi tường minh constructor lớp cơ sở, mặt khác constructor lớp dẫn xuất sẽ gọi constructor mặc định lớp cơ sở.

Các constructor lớp cơ sở và các toán tử gán lớp cơ sở không được kế thừa bởi lớp dẫn xuất.Tuy nhiên, các constructor và các toán tử gán lớp dẫn xuất có thể gọi các constructor và các toán tử gán lớp cơ sở.

Một constructor lớp dẫn xuất luôn gọi constructor lớp cơ sở của nó đầu tiên để khởi tạo các thành viên lớp cơ sở của lớp dẫn xuất. Nếu constructor lớp dẫn bị bỏ qua, constructor mặc định lớp dẫn gọi constructor lớp cơ sở. Các destructor được gọi theo thứ tự ngược lại thứ tự gọi các constructor, vì thế destructor lớp dẫn xuất được gọi trước destructor lớp cơ sở của nó.

Ví dụ 5.4: Minh họa thứ tự các contructor và destructor lớp cơ sở và lớp dẫn xuất được gọi và project có tên là CT5_4.PRJ

graphics9.pngFile POINT.H

1: //POINT.H

2: //Định nghĩa lớp Point

3: #ifndef POINT_H

4: #define POINT_H

5:

6: class Point

7: {

8: public:

9: Point(float A= 0.0, float B= 0.0);

10: ~Point();

11: protected:

12: float X, Y;

13: };

14:

15: #endif

Hình 8
Hình 8 (graphics10.png)
File POINT.CPP

1: //POINT.CPP

2: //Định nghĩa các hàm thành viên lớp Point

3: #include <iostream.h>

4: #include "point.h"

5:

6: Point::Point(float A, float B)

7: {

8: X = A;

9: Y = B;

10: cout << "Point constructor: "

11:            << '[' << X << ", " << Y << ']' << endl;

12: }

13:

14: Point::~Point()

15: {

16: cout << "Point destructor: "

17:            << '[' << X << ", " << Y << ']' << endl;

18: }

graphics11.pngFile CIRCLE.H

1: //CIRCLE.H

2: //Định nghĩa lớp Circle

3: #ifndef CIRCLE_H

4: #define CIRCLE_H

5:

6: #include "point.h"

7: #include <iomanip.h>

8:

9: class Circle : public Point

10: {

11: public:

12: Circle(float R = 0.0, float A = 0, float B = 0);

13: ~Circle();

14: private:

15: float Radius;

16: };

17:

18: #endif

Hình 9
Hình 9 (graphics12.png)
File CIRCLE.CPP

1: //CIRCLE.CPP

2: //Định nghĩa các hàm thành viên lớp Circle

3: #include "circle.h"

4:

5: Circle::Circle(float R, float A, float B): Point(A, B)

6: {

7: Radius = R;

8: cout << "Circle constructor: Radius is "

9:            << Radius << " [" << A << ", " << B << ']' << endl;

10: }

11:

12: Circle::~Circle()

13: {

14: cout << "Circle destructor: Radius is "

15:            << Radius << " [" << X << ", " << Y << ']' << endl;

16: }

Hình 10
Hình 10 (graphics13.png)
File CT5_4.CPP

1: //CT5_4.CPP

2: //Chương trình 5.4

3: #include <iostream.h>

4: #include "point.h"

5: #include "circle.h"

6: int main()

7: {

8: {

9: Point P(1.1, 2.2);

10: }

11: cout << endl;

12: Circle C1(4.5, 7.2, 2.9);

13: cout << endl;

14: Circle C2(10, 5, 5);

15: cout << endl;

16: return 0;

17: }

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

Hình 11
Hình 11 (graphics14.png)

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

Chuyển đổi ngầm định đối tượng lớp dẫn xuất sang đối tượng lớp cơ sở

Mặc dù một đối tượng lớp dẫn xuất cũng là một đối tượng lớp cơ sở, kiểu lớp dẫn xuất và kiểu lớp cơ sở thì khác nhau. Các đối tượng lớp dẫn xuất có thể được xử lý như các đối tượng lớp cơ sở. Điều này có ý nghĩa bởi vì lớp dẫn xuất có các thành viên tương ứng với mỗi thành viên của lớp cơ sở. Phép gán theo chiều hướng ngược lại là không cho phép bởi vì gán một đối tượng lớp cơ sở cho đối tượng lớp dẫn xuất sẽ cho phép thêm các thành viên lớp dẫn xuất không xác định.

Một con trỏ trỏ tới một đối tượng lớp dẫn xuất có thể được chuyển đổi ngầm định thành một con trỏ trỏ tới một đối tượng lớp cơ sở bởi vì một đối tượng lớp dẫn xuất là một đối tượng lớp cơ sở.

Có bốn cách để trộn và đối sánh các con trỏ lớp cơ sở và các con trỏ lớp dẫn xuất với các đối tượng lớp cơ sở và các đối tượng lớp dẫn xuất:

 Tham chiếu tới một đối tượng lớp cơ sở với một con trỏ lớp cơ sở thì không phức tạp.

 Tham chiếu tới một đối tượng lớp dẫn xuất với một con trỏ lớp dẫn xuất thì không phức tạp.

 Tham chiếu tới đối tượng lớp dẫn xuất với một con trỏ lớp cơ sở thì an toàn bởi vì đối tượng lớp dẫn xuất cũng là một đối tượng lớp cơ sở của nó. Như vậy đoạn mã chỉ có thể tham chiếu tới các thành viên lớp cơ sở. Nếu đoạn mã tham chiếu tới các thành viên lớp dẫn xuất thông qua con trỏ lớp cơ sở, trình biên dịch sẽ báo một lỗi về cú pháp.

 Tham chiếu tới một đối tượng lớp cơ sở với một con trỏ lớp dẫn xuất thì có lỗi cú pháp. Đầu tiên con trỏ lớp dẫn xuất phải được ép sang con trỏ lớp cơ sở.

ĐA KẾ THỪA (MULTIPLE INHERITANCE)

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).

graphics15.pngFile BASE1.H

1: //BASE1.H

2: //Định nghĩa lớp Base1

3: #ifndef BASE1_H

4: #define BASE1_H

5:

6: class Base1

7: {

8: protected:

9: int Value;

10: public:

11: Base1(int X)

12: {

13: Value = X;

14: }

15: int GetData() const

16: {

17: return Value;

18: }

19: };

20:

21: #endif

graphics16.pngFile BASE2.H

1: //BASE2.H

2: //Định nghĩa lớp Base2

3: #ifndef BASE2_H

4: #define BASE2_H

5:

6: class Base2

7: {

8: protected:

9: char Letter;

10: public:

11: Base2(char C)

12: {

13: Letter = C;

14: }

15: char GetData() const

16: {

17: return Letter;

18: }

19: };

20:

21: #endif

graphics17.pngFile DERIVED.H

1: //DERIVED.H

2: //Định nghĩa lớp Derived mà kế thừa từ nhiều lớp cơ sở (Base1 & Base2)

3: #ifndef DERIVED_H

4: #define DERIVED_H

5:

6: #include "base1.h"

7: #include "base2.h"

8:

9: class Derived : public Base1, public Base2

10: {

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

graphics18.pngFile DERIVED.CPP

1: //DERIVED.H

2: //Định nghĩa lớp Derived kế thừa từ nhiều lớp cơ sở (Base1 & Base2)

3: #ifndef DERIVED_H

4: #define DERIVED_H

5:

6: #include "base1.h"

7: #include "base2.h"

8:

9: class Derived : public Base1, public Base2

10: {

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

graphics19.pngFile CT5_8.CPP

1: //CT5_8.CPP

2: //Chương trình 5.8

3: #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() << endl

15:      << "Object B2 contains character "

16:      << B2.GetData() << endl

17:      << "Object D contains:" << endl << D << endl << endl;

18: cout << "Data members of Derived can be"

19:     << " accessed individually:" << endl

20:      << " Integer: " << D.Base1::GetData() << endl

21:      << " Character: " << D.Base2::GetData() << endl

22:      << "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 12
Hình 12 (graphics20.png)

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.

CÁC LỚP CƠ SỞ ẢO (VIRTUAL BASE CLASSES)

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.

Hình 13
Hình 13 (graphics21.png)
Ví dụ 5.9:

1: //Chương trình 5.9

2: #include <iostream.h>

3: class A

4: {

5: public:

6: int X1;

7: };

8:

9: class B : public A

10: {

11: public:

12: float X2;

13: };

14:

15: class C : public A

16: {

17: public:

18: double X3;

19: };

20:

21: class D : public B,public C

22: {

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ằng

32: Obj.X4='a';

33: Obj.X3=1.5;

34: cout<<"X1="<<Obj.X1<<endl; //Nhập nhằng

35: 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 14
Hình 14 (graphics22.png)

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:

Hình 15
Hình 15 (graphics23.png)
Ví dụ 5.10:

#include <iostream.h>

class A

{

public:

int X1;

};

class B : virtual public A

{

public:

float X2;

};

class C : virtual public A

{

public:

double X3;

};

class D : public B,public C

{

public:

char X4;

};

int main()

{

D Obj;

Obj.X2=3.14159F;

Obj.X1=0; //OK

Obj.X4='a';

Obj.X3=1.5;

cout<<"X1="<<Obj.X1<<endl; //OK

cout<<"X2="<<Obj.X2<<endl;

cout<<"X3="<<Obj.X3<<endl;

cout<<"X4="<<Obj.X4<<endl;

return 0;

}

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

Hình 16
Hình 16 (graphics24.png)

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.

BÀI TẬP

graphics25.pngBài 1: Xây dựng lớp Stack với các thao tác cần thiết. Từ đó hãy dẫn xuất từ lớp Stack để đổi một số nguyên dương sang hệ đếm bất kỳ.

graphics26.pngBài 2: Hãy xây dựng các lớp cần thiết trong phân cấp hình 5.2

graphics27.pngBài 3: Hãy xây dựng các lớp cần thiết trong phân cấp hình 5.3 để tính diện tích (hoặc diện tích xung quanh) và thể tích.

graphics28.pngBài 4: Viết một phân cấp kế thừa cho các lớp Quadrilateral (hình tứ giác), Trapezoid (hình thang), Parallelogram (hình bình hành), Rectangle (hình chữ nhật), và Square (hình vuông). Trong đó Quadrilateral là lớp cơ sở của phân cấp.

Content actions

Download module as:

PDF | EPUB (?)

What is an EPUB file?

EPUB is an electronic book format that can be read on a variety of mobile devices.

Downloading to a reading device

For detailed instructions on how to download this content's EPUB to your specific device, click the "(?)" link.

| More downloads ...

Add module to:

My Favorites (?)

'My Favorites' is a special kind of lens which you can use to bookmark modules and collections. 'My Favorites' can only be seen by you, and collections saved in 'My Favorites' can remember the last module you were on. You need an account to use 'My Favorites'.

| A lens I own (?)

Definition of a lens

Lenses

A lens is a custom view of the content in the repository. You can think of it as a fancy kind of list that will let you see content through the eyes of organizations and people you trust.

What is in a lens?

Lens makers point to materials (modules and collections), creating a guide that includes their own comments and descriptive tags about the content.

Who can create a lens?

Any individual member, a community, or a respected organization.

What are tags? tag icon

Tags are descriptors added by lens makers to help label content, attaching a vocabulary that is meaningful in the context of the lens.

| External bookmarks