0.5 Tính đa hình  (Page 4/4)

Các thành viên ảo của một lớp

Toán tử ảo

Toán tử thực chất cũng là một hàm nên chúng ta có thể tạo ra các toán tử ảo trong một lớp. Tuy nhiên do đa năng hóa khi tạo một toán tử cần chú ý đến các kiểu của các toán hạng phải sử dụng kiểu của lớp cơ sở gốc có toán tử ảo.

Ví dụ 6.4: Đa năng hóa toán tử với hàm toán tử là phương thức ảo.

1: //Chương trình 6.4: Toán tử ảo

2: #include<iostream.h>

3:

4: class A

5: {

6: protected:

7: int X1;

8: public:

9: A(int I)

10: {

11: X1=I;

12: }

13: virtual A&operator + (A&T);

14: virtual A&operator = (A&T);

15: virtual int GetA()

16: {

17: return X1;

18: }

19: virtual int GetB()

20: {

21: return 0;

22: }

23: virtual int GetC()

24: {

25: return 0;

26: }

27: void Print(char *St)

28: {

29: cout<<St<<":X1="<<X1<<endl;

30: }

31: };

32:

33: class B : public A

34: {

35: protected:

36: int X2;

37: public:

38: B(int I,int J):A(I)

39: {

40: X2=J;

41: }

42: virtual A&operator + (A&T);

43: virtual A&operator = (A&T);

44: virtual int GetB()

45: {

46: return X2;

47: }

48: void Print(char *St)

49: {

50: cout<<St<<":X1="<<X1<<",X2="<<X2<<endl;

51: }

52: };

53:

54: class C : public B

55: {

56: protected:

57: int X3;

58: public:

59: C(int I,int J,int K):B(I,J)

60: {

61: X3=K;

62: }

63: virtual A&operator + (A&T);

64: virtual A&operator = (A&T);

65: virtual int GetC()

66: {

67: return X3;

68: }

69: void Print(char *St)

70: {

71: cout<<St<<":X1="<<X1<<",X2="<<X2<<",X3="<<X3<<endl;

72: }

73: };

74:

75: A&A::operator + (A&T)

76: {

77: X1+=T.GetA();

78: return *this;

79: }

80:

81: A&A::operator = (A&T)

82: {

83: X1=T.GetA();

84: return *this;

85: }

86:

87: A&B::operator + (A&T)

88: {

89: X1+=T.GetA();

90: X2+=T.GetB();

91: return *this;

92: }

93:

94: A&B::operator = (A&T)

95: {

96: X1=T.GetA();

97: X2=T.GetB();

98: return *this;

99: }

100:

101:A&C::operator + (A&T)

102: {

103: X1+=T.GetA();

104: X2+=T.GetB();

105: X3+=T.GetC();

106: return *this;

107 }

108:

109: A&C::operator = (A&T)

110: {

111: X1=T.GetA();

112: X2=T.GetB();

113: X3=T.GetC();

114: return *this;

115: }

116:

117: void AddObject(A&T1,A&T2)

118: {

119: T1=T1+T2;

120: }

121:

122: int main()

123: {

124: A a(10);

125: B b(10,20);

126: C c(10,20,30);

127: a.Print("a");

128: b.Print("b");

129: c.Print("c");

130: AddObject(a,b);

131: a.Print("a");

132: AddObject(b,c);

133: b.Print("b");

134: AddObject(c,a);

135: c.Print("c");

136: a=b+c;

137: a.Print("a");

138: c=c+a;

139: c.Print("c");

140: return 0;

141: }

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

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

Có constructor và destructor ảo hay không?

Khi một đối tượng thuộc lớp có phương thức ảo, để thực hiện cơ chế kết nối động, trình biên dịch sẽ tạo thêm một con trỏ vptr như một thành viên của lớp, con trỏ này có nhiệm vụ quản lý địa chỉ của phương thức ảo. Một lớp chỉ có một bảng phương thức ảo, trong khi đó có thể có nhiều đối tượng thuộc lớp, nên khi một đối tượng khác thuộc cùng lớp tạo ra thì con trỏ vptr đã còn tại. Chính vì vậy bảng phương thức ảo phải được tạo ra trước khi gọi thực hiện constructor, nên constructor không thể là phương thức ảo. Ngược lại do một lớp chỉ có một bảng phương thức ảo nên khi một đối tượng thuộc lớp bị hủy bỏ, bảng phương thức ảo vẫn còn đó, và con trỏ vptr vẫn còn đó. Hơn nữa, destructor được gọi thực hiện trước khi vùng nhớ dành cho đối tượng bị thu hồi, do đó destructor có thể là phương thức ảo. Tuy nhiên, constructor của một lớp có thể gọi phương thức ảo khác. Điều này hoàn toàn không có gì mâu thuẫn với cơ chế kết nối động.

Ví dụ 6.5:

1: //Chương trình 6.5: Destructor ảo

2: #include<iostream.h>

3:

4: class Base

5: {

6: public:

7: virtual ~Base()

8: {

9: cout<<"~Base"<<endl;

10: }

11: };

12:

13: class Derived:public Base

14: {

15: public:

16: virtual ~Derived()

17: {

18: cout<<"~Derived"<<endl;

18: }

19: };

20:

21: int main()

22: {

23: Base *B;

24: B = new Derived;

25: delete B;

26: return 0;

27: }

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

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

Nếu destructor không là phương thức ảo thì khi giải phóng đối tượng B chỉ có destructor của lớp cơ sơ được gọi mà thôi nhưng khi destructor là phương thức ảo thì khi giải phóng đối tượng B (ở dòng 25) destructor của lớp dẫn xuất được gọi thực hiện rồi đến destructor của lớp cơ sơ.

BÀI TẬP

Bài 1: 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 trong đó lớp Shape là lớp cơ sở trừu tượng.

Bài 2: Hãy sửa đổi hệ thống lương của chương trình ở ví dụ 6.6 bằng thêm các thành viên dữ liệu BrithData (một đối tượng kiểu Date) và DepartmentCode (kiểu int) vào lớp Employee. Giả sử lương này được xử lý một lần trên một tháng. Sau đó, chương trình tính bảng lương cho mỗi Employee (tính đa hình), cộng thêm 100.00$ tiền thưởng vào tổng số lương của mỗi người nếu đây là tháng mà ngày sinh của Employee xảy ra.

Bài 3: Cài đặt các lớp trong cây phả hệ lớp sau:

Trong đó các lớp Person, Student và Staff là các lớp trừu tượng, các lớp còn lại là các lớp dẫn xuất thực.