Đa năng hóa toán tử trong Lập trình hướng đối tượng (Phần 1)
Trong chương 3, chúng ta đã tìm hiểu các điều cơ bản của các lớp C++ và khái niệm kiểu dữ liệu trừu tượng (ADTs). Các thao tác trên các đối tượng của lớp (nghĩa là các thực thể của ADTs) được thực hiện bởi gởi các thông điệp (dưới dạng các ...
Trong chương 3, chúng ta đã tìm hiểu các điều cơ bản của các lớp C++ và khái niệm kiểu dữ liệu trừu tượng (ADTs). Các thao tác trên các đối tượng của lớp (nghĩa là các thực thể của ADTs) được thực hiện bởi gởi các thông điệp (dưới dạng các lời gọi hàm thành viên) tới các đối tượng. Ký pháp gọi hàm này thì cồng kềnh cho các loại lớp nhất định, đặc biệt là các lớp toán học. Đối với các loại lớp này sẽ là đẹp để sử dụng tập các toán tử có sẵn phong phú của C++ để chỉ rõ các thao tác của đối tượng. Trong chương này tìm hiểu làm thế nào cho phép các toán tử của C++ làm việc với các đối tượng của lớp. Xử lý này được gọi là đa năng hóa toán tử (operator overloading).
Toán tử << được sử dụng nhiều mục đích trong C++ đó là toán tử chèn dòng (stream-insertion) và toán tử dịch chuyển trái. Đây là một ví dụ của đa năng hóa toán tử. Tương tự >> cũng được đa năng hóa. Nó được sử dụng vừa toán tử trích dòng (stream-extraction) và toán tử dịch chuyển phải.
C++ cho phép các lập trình viên đa năng hóa hầu hết các toán tử để biểu thị ngữ cảnh mà trong đó chúng được sử dụng. Trình biên dịch phát sinh đoạn mã thích hợp dựa trên kiểu mà trong đó toán tử được sử dụng. Một vài toán tử được đa năng hóa thường xuyên, đặc biệt là toán tử gán và các toán tử số học như + và -. Công việc thực hiện bởi đa năng hóa các toán tử cũng có thể được thực hiện bởi các lời gọi hàm tường minh, nhưng ký pháp thường sử dụng dễ dàng để đọc.
Lập trình viên có thể sử dụng các kiểu có sẵn và có thể định nghĩa các kiểu mới. Các kiểu có thể được sử dụng với tập các toán tử phong phú. Các toán tử cung cấp cho các lập trình viên với ký pháp ngắn ngọn cho việc biểu thị các thao tác của đối tượng của các kiểu có sẵn.
Các lập trình viên có thể sử dụng các toán tử với các kiểu do người dùng định nghĩa. Mặc dù C++ không cho phép các toán tử mới được tạo, nó cho phép các toán tử đã tồn tại được đa năng hóa sao cho khi các toán tử này được sử dụng với các đối tượng của lớp, các toán tử có ý nghĩa thích hợp các kiểu mới. Đây chính là một đặc điểm mạnh của C++.
Các toán tử được đa năng hóa bằng cách viết một định nghĩa hàm (bao gồm phần đầu và thân) như khi chúng ta viết một hàm bình thường, ngoại trừ tên hàm bây giờ trở thành từ khóa operator theo sau bởi ký hiệu của toán tử được đa năng hóa. Prototype của nó có dạng như sau:
type operator operator_symbol ( parameter_list );
Để sử dụng một toán tử một các đối tượng của lớp, toán tử phải được đa năng hóa ngoại trừ hai điều. Điều thứ nhất toán tử gán có thể sử dụng với mọi lớp mà không cần đa năng hóa. Cách cư xử mặc định của toán tử gán là một phép gán thành viên của các thành viên dữ liệu của lớp. Chúng ta nhận thấy rằng sao chép thành viên mặc định thì nguy hiểm đối với các lớp với các thành viên mà được cấp phát động. Chúng ta sẽ đa năng hóa một cách tường minh toán tử gán đối với các lớp như thế. Điều thứ hai toán tử địa chỉ (&) cũng có thể được sử dụng với các đối tượng của bất kỳ lớp nào mà không cần đa năng hóa; Nó trả về địa chỉ của đối tượng trong bộ nhớ. Toán tử địa chỉ cũng có thể được đa năng hóa.
Phần lớn các toán tử của C++ có thể được đa năng hóa. Hình 4.1 cho thấy các toán tử có thể được đa năng hóa và hình 4.1 là các toán tử không thể đa năng hóa.
Các toán tử có thể được đa năng hóa (Hình 4.1)
Các toán tử không thể đa năng hóa (Hình 4.2)
Chú ý rằng toán tử ngoặc tròn () trong bảng 4.1 là toán tử gọi hàm. Vì toán tử này đứng sau tên hàm có thể chứa trong nó nhiều tham số do đó toán tử ngoặc tròn là một toán tử nhiều ngôi.
Thứ tự ưu tiên của một toán tử không thể được thay đổi bởi đa năng hóa. Điều này có thể dẫn tới các tình trạng bất tiện trong đó một toán tử được đa năng hóa theo một cách đối với mức độ ưu tiên cố định của nó thì không thích hợp. Tuy nhiên, các dấu ngoặc đơn có thể được sử dụng để đặt thứ tự ước lượng của các toán tử đã đa năng hóa trong một biểu thức.
Tính kết hợp của một toán tử không thể được thay đổi bởi đa năng hóa. Các tham số mặc định không thể sử dụng với một toán tử đa năng hóa.
Không thể thay đổi số các toán hạng mà một toán tử yêu cầu: Đa năng hóa các toán tử một ngôi vẫn là các toán tử một ngôi; đa năng hóa các toán tử hai ngôi vẫn là các toán tử hai ngôi. Toán tử ba ngôi duy nhất (?:) của C++ không thể đa năng hóa. Các toán tử &, *, + và – mỗi toán tử có các phiên bản một và hai ngôi.; Các phiên bản một và hai ngôi này có thể được đa năng hóa riêng biệt.
Ý nghĩa của làm sao một toán tử làm việc trên các đối tượng của các kiểu có sẵn không thể thay đổi bởi việc đa năng hóa toán tử. Chẳng hạn, lập trình viên không thể thay đổi ý nghĩa của làm sao toán tử (+) cộng hai số nguyên. Việc đa năng hóa toán tử chỉ làm việc với các đối tượng của các kiểu do người dùng định nghĩa hoặc với một sự pha trộn của một đối tượng của kiểu do người dùng định nghĩa và một đối tượng của một kiểu có sẵn.
Đa năng hóa một toán tử gán và một toán tử cộng để cho phép các lệnh như là:
object2 = object2 + object1
không bao hàm toán tử += cũng được đa năng hóa để phép các lệnh như là:
object2 += object1
Hành vi như thế có thể được thực hiện bởi việc đa năng hóa rõ ràng toán tử += cho lớp đó.
Các hàm toán tử có thể là các hàm thành viên hoặc hàm không thành viên; hàm không thành viên thường là các hàm friend. Các hàm thành viên sử dụng ngầm con trỏ this để chứa một trong các tham số đối tượng lớp của chúng. Tham số lớp đó phải được liệt kê một cách tường minh trong lời gọi hàm không thành viên.
Khi đa năng hóa (), [], -> hoặc =, hàm đa năng hóa toán tử phải được khai báo như một thành viên lớp. Đối với các toán tử khác, các hàm đa năng hóa toán tử có thể là các hàm không thành viên (thường là các hàm friend).
Liệu có phải một hàm toán tử được cài đặt như một hàm thành viên hoặc như hàm không thành viên, toán tử vẫn còn được sử dụng cùng cách trong biểu thức. Như vậy cách là cách cài đặt nào tốt nhất?
Khi một hàm toán tử được cài đặt như một hàm thành viên, toán hạng cực trái phải là một đối tượng lớp của toán tử. Nếu toán hạng bên trái phải là một đối tượng của lớp khác hoặc một kiểu có sẵn thì hàm toán tử này phải được cài đặt như hàm không thành viên. Một hàm toán tử cài đặt như hàm không thành viêân cần là một friend nếu hàm phải truy cập đến các thành viên private hoặc protected.
Các hàm thành viên chỉ được gọi khi toán hạng trái của một toán tử hai ngôi là một đối tượng cụ thể của lớp đó, hoặc khi toán hạng đơn của một toán tử một ngôi là một đối tượng của lớp đó.
Ví dụ 4.1: Chúng ta xây dựng lớp số phức với tên lớp là Complex và đa năng hóa toán tử + trên lớp này.
1: #include <iostream.h>
2:
3: class Complex
4: {
5: private:
6: double Real, Imaginary;
7: public:
8: Complex(double R=0.0,double I=0.0);// Constructor mặc định
9: void Print(); // Hiển thị số phức
10: Complex operator+(Complex Z); // Phép cộng giữa hai số phức
11: Complex operator+(double R); //cộng một số phức với một số thực
12: };
13:
14: Complex::Complex(double R,double I)
15: {
16: Real = R;
17: Imaginary = I;
18: }
19:
20: void Complex::Print()
21: {
22: cout<<'('<<Real<<','<<Imaginary<<')';
23: }
24:
25: Complex Complex::operator + (Complex Z)
26: {
27: Complex Tmp;
28: Tmp.Real = Real + Z.Real;
29: Tmp.Imaginary = Imaginary + Z.Imaginary;
30: return Tmp;
31: }
32:
33: Complex Complex::operator + (double R)
34: {
35: Complex Tmp;
36: Tmp.Real = Real + R;
37: Tmp.Imaginary = Imaginary;
38: return Tmp;
39: }
40:
41: int main()
42: {
43: Complex X,Y(4.3,8.2),Z(3.3,1.1);
44: cout<<"X: ";
45: X.Print();
46: cout<<endl<<"Y: ";
47: Y.Print();
48: cout<<endl<<"Z: ";
49: Z.Print();
50: X = Y + Z;
51: cout<<endl<<endl<<"X = Y + Z:"<<endl;
52: X.Print();
53: cout<<" = ";
54: Y.Print();
55: cout<<" + ";
56: Z.Print();
57: X = Y + 3.5;
58: cout<<endl<<endl<<"X = Y + 3.5:"<<endl;
59: X.Print();
60: cout<<" = ";
61: Y.Print();
62: cout<<" + 3.5";
63: return 0;
64: }
Hàm thành viên toán tử operator + () (từ dòng 25 đến 31 và từ dòng 33 đến 39) trả về một đối tượng có kiểu Complex là tổng của hai số phức hoặc tổng của một số phức với một số thực. Chú ý rằng đối tượng tam thời Tmp được dùng bên trong hàm operator + () để giữ kết quả, và đó là đối tượng được trả về.
Chúng ta chạy ví dụ 4.1, kết quả ở hình 4.3
Kết quả của ví dụ 4.1 (Hình 4.3)
Do đa năng hóa toán tử + trên lớp Complex ở ví dụ 4.1, chúng ta có thể viết:
X = Y + Z;
Câu lệnh này được trình biên dịch hiểu:
X = Y.operator + (Z);
Như vậy, trong biểu thức Y + Z đối tượng bên trái toán tử + (là đối tượng Y) là đối tượng mà qua đó, hàm thành viên toán tử operator + () được gọi. Do đó hàm thành viên toán tử + chỉ nhận một tham số là đối tượng bên phải toán tử và đối tượng bên trái toán tử là đối tượng tạo lời gọi cho hàm toán tử và được truyền bởi con trỏ this.
Hàm operator + () trả về một đối tượng Complex. Do vậy chúng ta có thể viết:
(Y + Z).Print();
để in trên màn hình số phức của đối tượng được trả về. Đối tượng do Y + Z sinh ra như vậy là một đối tượng tạm thời. Nó sẽ không tồn tại khi hàm thành Print() kết thúc.
Hơn nữa khi trả về một đối tượng, toán tử + cho phép một chuỗi phép cộng. Nên chúng ta cũng có thể viết:
X = X + Y + Z;
Tuy nhiên chúng ta không thể nào viết được câu lệnh sau:
X = 3.5 + Y; // Lỗi !!!
Chính vì lý do này chúng ta chọn một hàm không thành viên để đa năng hóa một toán tử để cho phép toán tử được giao hoán. Chú ý rằng hàm không thành viên không cần thiết phải là hàm friend nếu các hàm set và get thích hợp tồn tại trong phần giao diện public, và đặt biệt nhất nếu các hàm set và get là các hàm inline.
Để đa năng hóa toán tử << phải có một toán hạng trái của kiểu ostream & (như là cout trong biểu thức cout<<X), vì thế nó phải là hàm không thành viên. Tương tự, đa năng hóa toán tử >> phải có một toán hạng trái của kiểu istream & (như là cin trong biểu thức cin>>X), vì thế vì thế nó cũng phải là hàm không thành viên.
Ngoại trừ đa năng hóa toán tử >> và << liên quan đến dòng nhập/xuất dữ liệu chúng ta có hình 4.4 về cách đa năng hóa toán tử như sau:
Việc cài đặt các hàm toán tử (Hình 4.4)
Các toán tử hai ngôi được đa năng hóa trong hình 4.5 sau:
Các toán tử hai ngôi được đa năng hóa (Hình 4.5)
Một toán tử hai ngôi có thể được đa năng hóa như là hàm thành viên không tĩnh với một tham số hoặc như một hàm không thành viên với hai tham số (một trong các tham số này phải là hoặc là một đối tượng lớp hoặc là một tham chiếu đến đối tượng lớp).
Ví dụ 4.2: Chúng ta xây dựng lớp số phức với tên lớp là Complex và đa năng hóa các toán tử tính toán + - += -= và các toán tử so sánh == != > >= < <= với các hàm toán tử là các hàm thành viên.
1: #include <iostream.h>
2: #include <math.h>
3:
4: class Complex
5: {
6: private:
7: double Real, Imaginary;
8: public:
9: Complex(); // Constructor mặc định
10: Complex(double R,double I);
11: Complex (const Complex & Z); // Constructor sao chép
12: Complex (double R); // Constructor chuyển đổi
13: void Print(); // Hiển thị số phức
14: // Các toán tử tính toán
15: Complex operator + (Complex Z);
16: Complex operator - (Complex Z);
17: Complex operator += (Complex Z);
18: Complex operator -= (Complex Z);
19: // Các toán tử so sánh
20: int operator == (Complex Z);
21: int operator != (Complex Z);
22: int operator > (Complex Z);
23: int operator >= (Complex Z);
24: int operator < (Complex Z);
25: int operator <= (Complex Z);
26: private:
27: double Abs(); // Giá trị tuyệt đối của số phức
28: };
29:
30: Complex::Complex()
31: {
32: Real = 0.0;
33: Imaginary = 0.0;
34: }
35:
36: Complex::Complex(double R,double I)
37: {
38: Real = R;
39: Imaginary = I;
40: }
41:
42: Complex::Complex(const Complex & Z)
43: {
44: Real = Z.Real;
45: Imaginary = Z.Imaginary;
46: }
47:
48: Complex::Complex(double R)
49: {
50: Real = R;
51: Imaginary = 0.0;
52: }
53:
54: void Complex::Print()
55: {
56: cout<<'('<<Real<<','<<Imaginary<<')';
57: }
58:
59: Complex Complex::operator + (Complex Z)
60: {
61: Complex Tmp;
62
63: Tmp.Real = Real + Z.Real;
64: Tmp.Imaginary = Imaginary + Z.Imaginary;
65: return Tmp;
66: }
67:
68: Complex Complex::operator - (Complex Z)
69: {
70: Complex Tmp;
71:
72: Tmp.Real = Real - Z.Real;
73: Tmp.Imaginary = Imaginary - Z.Imaginary;
74: return Tmp;
75: }
76:
77: Complex Complex::operator += (Complex Z)
78: {
79: Real += Z.Real;
80: Imaginary += Z.Imaginary;
81: return *this;
82: }
83:
84: Complex Complex::operator -= (Complex Z)
85: {
86: Real -= Z.Real;
87: Imaginary -= Z.Imaginary;
88: return *this;
89: }
90:
91: int Complex::operator == (Complex Z)
92: {
93: return (Real == Z.Real) && (Imaginary == Z.Imaginary);
94: }
95:
96: int Complex::operator != (Complex Z)
97: {
98: return (Real != Z.Real) || (Imaginary != Z.Imaginary);
99: }
100:
101: int Complex::operator > (Complex Z)
102: {
103: return Abs() > Z.Abs();
104: }
105:
106: int Complex::operator >= (Complex Z)
107: {
108: return Abs() >= Z.Abs();
109: }
110:
111: int Complex::operator < (Complex Z)
112: {
113: return Abs() < Z.Abs();
114: }
115:
116: int Complex::operator <= (Complex Z)
117: {
118: return Abs() <= Z.Abs();
119: }
120:
121: double Complex::Abs()
122: {
123: return sqrt(Real*Real+Imaginary*Imaginary);
124: }
125:
126: int main()
127: {
128: Complex X, Y(4.3,8.2), Z(3.3,1.1), T;
129
130: cout<<"X: ";
131: X.Print();
132: cout<<endl<<"Y: ";
133: Y.Print();
134: cout<<endl<<"Z: ";
135: Z.Print();
136: cout<<endl<<"T: ";
137: T.Print();
138: T=5.3;// Gọi constructor chuyển kiểu
139: cout<<endl<<endl<<"T = 5.3"<<endl;
140: cout<<"T: ";
141: T.Print();
142: X = Y + Z;
143: cout<<endl<<endl<<"X = Y + Z: ";
144: X.Print();
145: cout<<" = ";
146: Y.Print();
147: cout<<" + ";
148: Z.Print();
149: X = Y - Z;
150: cout<<endl<<"X = Y - Z: ";
151: X.Print();
152: cout<<" = ";
153: Y.Print();
154: cout<<" - ";
155: Z.Print();
156: cout<<endl<<endl<<"Y += T i.e ";
157: Y.Print();
158: cout<<" += ";
159: T.Print();
160: Y += T;
161: cout<<endl<<"Y: ";
162: Y.Print();
163: cout<<endl<<"Z -= T i.e ";
164: Z.Print();
165: cout<<" -= ";
166: T.Print();
167: Z -= T;
168: cout<<endl<<"Z: ";
169: Z.Print();
170: Complex U(X);// Gọi constructor sao chép
171: cout<<endl<<endl<<"U: ";
172: U.Print();
173: cout<<endl<<endl<<"Evaluating: X==U"<<endl;
174: if (X==U)
175: cout<<"They are equal"<<endl;
176: cout<<"Evaluating: Y!=Z"<<endl;
177: if (Y!=Z)
178: cout<<"They are not equal => ";
179: if (Y>Z)
180: cout<<"Y>Z";
181: else
182: cout<<"Y<Z";
183: return 0;
184: }
Chúng ta chạy ví dụ 4.2, kết quả ở hình 4.6.
Dòng thứ 10 của chương trình ở ví dụ 4.2: Complex(const Complex &Z);
là một constructor sao chép (copy constructor). Nó khởi động một đối tượng lớp bằng cách tạo một sao chép của một đối tượng lớp đó. Constructor sao chép thực hiện công việc giống như toán tử sao chép nhưng nó có một vai trò đặc biệt. Constructor sao chép chỉ nhận tham số là một tham chiếu chỉ đến đối tượng thuộc chính lớp mà nó được định nghĩa. Các constructor sao chép được dùng mỗi khi một sự sao chép của một đối tượng cần thiết như khi có sự truyền tham số bằng trị, khi trả về một đối tượng từ hàm, hoặc khi khởi động một đối tượng mà được sao chép từ đối tượng khác của cùng lớp. Chẳng hạn:
Complex A(3.5, 4.5);
Complex B(A); // Gọi constructor sao chép
Complex C = B; // Gọi constructor sao chép
…………………
Complex MyFunc(Complex Z) // Gọi constructor sao chép
{ rZ; // Gọi constructor sao chép }
Kết quả của ví dụ 4.2 (Hình 4.6)Chúng ta chú ý rằng, dấu = trong câu lệnh trên ứng với constructor sao chép chứ không phải là toán tử gán . Nếu chúng ta không định nghĩa constructor sao chép, trình biên dịch tạo ra một constructor sao chép mặc định sẽ sao chép từng thành viên một.
Ở dòng 12 của chương trình ở ví dụ 4.2:
Complex(double R);
là một constructor chuyển đổi (conversion constructor). Constructor này lấy một tham số double và khởi tạo đối tượng Complex mà phần thực bằng giá trị tham số truyền vào và phần ảo bằng 0.0 (từ dòng 48 đến 52). Bất kỳ một constructor nào có tham số đơn có thể được nghĩ như một constructor chuyển đổi. Constructor chuyển đổi sẽ đổi một số thực thành một đối tượng Complex rồi gán cho đối tượng đích Complex. Chẳng hạn:
T = 3.5; // Ngầm định: T = Complex(3.5)
Trình biên dịch tự động dùng constructor chuyển đổi để tạo một đối tượng tạm thời Complex, rồi dùng toán tử gán để gán đối tượng tạm thời này cho đối tượng khác của Complex. Chẳng hạn câu lệnh sau vẫn đúng:
X = Y + 3.5; // Ngầm định: X = Y + Complex(3.5);
Như vậy một constructor chuyển đổi được sử dụng để thực hiện một sự chuyển đổi ngầm định.
Ví dụ 4.3: Lấy lại ví dụ 4.2 nhưng các hàm toán tử +, - và các hàm toán tử so sánh là hàm không thành viên.
#include <iostream.h>
#include <math.h>
class Complex
{
private:
double Real,Imaginary;
public:
Complex();//Constructor mac dinh
Complex(double R,double I);
Complex (const Complex & Z);//Constructor sao chep
Complex (double R);//Constructor chuyen doi
void Print();//Hien thi so phuc
//Cac toan tu tinh toan
friend Complex operator + (Complex Z1,Complex Z2);
friend Complex operator - (Complex Z1,Complex Z2);
Complex operator += (Complex Z);
Complex operator -= (Complex Z);
//Cac toan tu so sanh
friend int operator == (Complex Z1,Complex Z2);
friend int operator != (Complex Z1,Complex Z2);
friend int operator > (Complex Z1,Complex Z2);
friend int operator >= (Complex Z1,Complex Z2);
friend int operator < (Complex Z1,Complex Z2);
friend int operator <= (Complex Z1,Complex Z2);
private:
double Abs();//Gia tri tuyet doi cua so phuc
};
Complex::Complex()
{
Real = 0.0;
Imaginary = 0.0;
}
Complex::Complex(double R,double I)
{
Real = R;
Imaginary = I;
}
Complex::Complex(const Complex & Z)
{
Real = Z.Real;
Imaginary = Z.Imaginary;
}
Complex::Complex(double R)
{
Real = R;
Imaginary = 0.0;
}
void Complex::Print()
{
cout<<'('<<Real<<','<<Imaginary<<')';
}
Complex operator + (Complex Z1,Complex Z2)
{
Complex Tmp;
Tmp.Real = Z1.Real + Z2.Real;
Tmp.Imaginary = Z1.Imaginary + Z2.Imaginary;
return Tmp;
}
Complex operator - (Complex Z1,Complex Z2)
{
Complex Tmp;
Tmp.Real = Z1.Real - Z2.Real;
Tmp.Imaginary = Z1.Imaginary - Z2.Imaginary;
return Tmp;
}
Complex Complex::operator += (Complex Z)
{
Real += Z.Real;
Imaginary += Z.Imaginary;
return *this;
}
Complex Complex::operator -= (Complex Z)
{
Real -= Z.Real;
Imaginary -= Z.Imaginary;
return *this;
}
int operator == (Complex Z1,Complex Z2)
{
return (Z1.Real == Z2.Real) && (Z1.Imaginary == Z2.Imaginary);
}
int operator != (Complex Z1,Complex Z2)
{
return (Z1.Real != Z2.Real) || (Z1.Imaginary != Z2.Imaginary);
}
int operator > (Complex Z1,Complex Z2)
{
return Z1.Abs() > Z2.Abs();
}
int operator >= (Complex Z1,Complex Z2)
{
return Z1.Abs() >= Z2.Abs();
}
int operator < (Complex Z1,Complex Z2)
{
return Z1.Abs() < Z2.Abs();
}
int operator <= (Complex Z1,Complex Z2)
{
return Z1.Abs() <= Z2.Abs();
}
double Complex::Abs()
{
return sqrt(Real*Real+Imaginary*Imaginary);
}
int main()
{
Complex X,Y(4.3,8.2),Z(3.3,1.1);
cout<<"X: "; X.Print();
cout<<endl<<"Y: "; Y.Print();
cout<<endl<<"Z: "; Z.Print();
X = Y + 3.6;
cout<<endl<<endl<<"X = Y + 3.6: ";
X.Print(); cout<<" = ";
Y.Print(); cout<<" + 3.6 ";
X = 3.6 + Y; cout<<endl<<"X = 3.6 + Y: ";
X.Print(); cout<<" = 3.6 + ";
Y.Print(); X = 3.8 - Z;
cout<<endl<<"X = 3.8 - Z: ";
X.Print(); cout<<" = 3.8 - ";
Z.Print(); X = Z - 3.8;
cout<<endl<<"X = Z - 3.8: ";
X.Print(); cout<<" = ";
Z.Print(); cout<<" - 3.8 ";
return 0;
}
Chúng ta chạy ví dụ 4.3, kết quả ở hình 4.7
Kết quả của ví dụ 4.3 (Hình 4.7)
