Lập trình hướng đối tượng - Chương 5 pdf

Chương 5


Quá tải toán tử







•
Quá tải toán tử đối với lớp

•
Quá tải toán tử nhò nguyên

•
Quá tải toán tử quan hệ & luận lý

•
Quá tải toán tử đơn nguyên

•
Hàm toán tử friend

•

Toán tử gán











Chöông 5
Quaù taûi toaùn töû



136
136

Chương 5

Quá tải toán tử



137
137
I/ Quá tải toán tử
(operator overloading)

Quá tải toán tử
giống như quá tải hàm. Thực chất quá tải toán tử chỉ là một loại quá
tải hàm. Một toán tử thường được quá tải đối với một lớp.

Khi một toán tử được quá tải, toán tử đó không mất ý nghóa gốc của nó. Thêm nữa,
toán tử còn có thêm ý nghiã bổ sung đối với lớp mà toán tử được đònh nghiã.


•
Để quá tải một toán tử, hãy tạo ra
một hàm toán tử
(operator function). Thông
thường, một hàm toán tử là một thành viên (member) hoặc bạn (friend) của lớp
mà toán tử được đònh nghiã.

Cú pháp
return_type class_name::
operator#
(arg_list)
{
// operation to be performed

}

return_type kiểu trả về của một hàm toán tử có thể là bất kỳ,
thường là lớp mà toán tử được đònh nghiã
class_name tên lớp chứa hàm toán tử
#
đại diện cho toán tử được quá tải
arg_list danh sách các đối số, thay đổi phụ thuộc vào cách mà hàm toán tử
được thực hiện và kiểu toán tử được quá tải

•
Hai hạn chế khi quá tải toán tử :
+ thứ tụ ưu tiên của các toán tử không thay đổi
+ số toán hạng của một toán tử không thay đổi

Hầu hết các toán tử trong C++ có thể được quá tải.
Một số toán tử không thể quá tải như :
::
,
.
,
*
,
?

Cũng không thể quá tải toán tử tiền xử lý.

Hai toán tử được quá tải ">>" và "<<" , dùng để thực hiện các thao tác nhập/xuất
trong C++

•
Các hàm toán tử có thể không có các đối số ngầm đònh.
Chương 5
Quá tải toán tử



138
138
II/ Quá tải toán tử nhò nguyên

Khi một hàm toán tử thành viên quá tải toán tử nhò nguyên, hàm sẽ chỉ có một tham
số. Tham số này sẽ nhận
đối tượng nằm bên phải
toán tử. Đối tượng bên trái là đối
tượng tạo ra lời gọi. Gọi cho hàm toán tử và được truyền bởi con trỏ
this
.

Các hàm toán tử được viết theo nhiều cách khác nhau.

•
Quá tải toán tử "+" đối với một lớp

Ví dụ 2.1
// Overload the + relative to coord class.
#include <iostream.h>

class coord {
int x, y; // coordinate values

public:
coord() { x=0; y=0; }
coord(int i, int j) { x=i; y=j; }
void get_xy(int &i, int &j) { i=x; j=y; }

coord operator+(coord ob2)
;
};

// Overload + relative to coord class.
coord coord::operator+(coord ob2)
{
coord temp;
temp.x = x + ob2.x;
temp.y = y + ob2.y;

return
temp
;
}

int main()
{
coord o1(10, 10), o2(5, 3), o3;
int x, y;
Chương 5
Quá tải toán tử

139
139
o3 =
o1 + o2
; // add two objects - this calls operator+()
o3.get_xy(x, y);
cout << "(o1+o2) X: " << x << ", Y: " << y << "\n";

return 0;
}

@ Khi trả về một đối tượng, toán tử phép "+" cho phép một chuổi phép cộng, ví dụ
o3 = o1 + o2 + o1 + o3;

@ Vì đối tượng coord được trả về, câu lệnh sau đây cũng hoàn toàn đúng
(o1
+
o2).get_xy(x, y);


•
Quá tải toán tử "-" , "=" đối với một lớp

Ví dụ 2.2
// Overload the +, -, and = relative to coord class.
#include <iostream.h>

class coord {
int x, y; // coordinate values
public:

coord() { x=0; y=0; }
coord(int i, int j) { x=i; y=j; }
void get_xy(int &i, int &j) { i=x; j=y; }
coord operator+(coord ob2);
coord
operator-(coord ob2)
;
coord
operator=(coord ob2)
;
};

// Overload + relative to coord class.
coord
coord::operator+(coord ob2)

{
coord temp;

temp.x = x + ob2.x;
Chöông 5
Quaù taûi toaùn töû



140
140
temp.y = y + ob2.y;
return temp;
}

// Overload - relative to coord class.
coord
coord::operator-(coord ob2)

{
coord temp;

temp.x =
x - ob2.x
;
temp.y =
y - ob2.y
;

return
temp
;
}

// Overload = relative to coord.
coord
coord::operator=(coord ob2)

{
x = ob2.x;
y = ob2.y;

return
*this
; // return the object that is assigned

}

int main()
{
coord o1(10, 10), o2(5, 3), o3;
int x, y;

o3 = o1 + o2; // add two objects - this calls operator+()
o3.get_xy(x, y);
cout << "(o1+o2) X: " << x << ", Y: " << y << "\n";


o3 = o1 - o2
; // subtract two objects
o3.get_xy(x, y);
cout << "(o1-o2) X: " << x << ", Y: " << y << "\n";


o3 = o1
; // assign an object
Chương 5
Quá tải toán tử



141
141
o3.get_xy(x, y);
cout << "(o3=o1) X: " << x << ", Y: " << y << "\n";

return 0;
}
@ Với hàm operator-() thứ tự của các toán hạng là quan trọng. Do A-B sẽ khác B-A
.
Vì chính
toán hạng bên trái tạo ra lời gọi
đối với operator-() nên phép trừ phải
theo thứ tự : x - ob2.x ;

@ Với hàm toán tử gán
+ toán hạng bên trái (nghiã là đối tượng được gán cho một giá trò)
được thay đổi bởi phép toán.
+ hàm operator=() trả về con trỏ this, nghiã là hàm trả về đối tượng
sẽ được gán. Do đó câu lệnh sau cũng hoàn toàn đúng :
o3 = o2 = o1;


•
Có thể quá tải một toán tử đối với một lớp để cho toán hạng bên phải là một
đối
tượng có kiểu đònh sẵn.
Toán tử "+" được quá tải để cộng một giá trò nguyên và
đối tượng coord.

Ví dụ 2.3
// Overload + for ob + int as well as ob + ob.
#include <iostream.h>

class coord {
int x, y; // coordinate values

public:
coord() { x=0; y=0; }
coord(int i, int j) { x=i; y=j; }
void get_xy(int &i, int &j) { i=x; j=y; }
coord operator+(coord ob2); // ob + ob

coord operator+(int i)
; // ob + int
};

// Overload + relative to coord class.
Chöông 5
Quaù taûi toaùn töû



142
142
coord coord::operator+(coord ob2)
{
coord temp;

temp.x = x + ob2.x;
temp.y = y + ob2.y;
return temp;
}
// Overload + for ob + int
coord coord::operator+(int i)
{
coord temp;

temp.x = x
+ i
;
temp.y = y
+ i
;

return temp;
}


int main()
{
coord o1(10, 10), o2(5, 3), o3;
int x, y;

o3 = o1 + o2; // add two objects - this calls operator+(coord)

o3.get_xy(x, y);
cout << "(o1+o2) X: " << x << ", Y: " << y << "\n";


o3 = o1 + 100
; // add object + int - this call operator+(int)

o3.get_xy(x, y);
cout << "(o1+100) X: " << x << ", Y: " << y << "\n";

return 0;

}
Chương 5
Quá tải toán tử



143
143
@ Cần nhớ, khi quá tải một hàm toán tử thành viên để cho một đối tượng có thể
được dùng trong một phép toán có kiểu đònh sẵn, thì
kiểu đònh sẵn phải ở bên phải
của toán tử. Bởi vì chính đối tượng bên trái tạo ra lời gọi cho hàm toán tử.

Điều gì xảy ra cho câu lệnh này ?

o3 = 100 + o1; // int + ob

•
Có thể dùng
tham số qui chiếu
trong một hàm toán tử

Ví dụ 2.4
// Overload + relative to coord class using references.
coord coord::operator+(coord
&ob2
)
{
coord temp;

temp.x = x + ob2.x;
temp.y = y + ob2.y;

return temp;
}


@ Các lý do phải dùng tham số qui chiếu trong hàm toán tử :
+ Sự hiệu quả. Do việc truyền điạ chỉ của một đối tượng thường nhanh hơn và
cải thiện năng xuất so với truyền các đối tượng như các tham số cho hàm.

+ Tránh những rắc rối gây ra khi bản sao một toán hạng bò hủy. Tuy nhiên, có thể
đònh nghiã một hàm hủy bản sao để ngăn ngừa vấn đề này trong trường hợp tổng
quát.


Bài tập II

1. Hãy tạo quá tải toán tử "*" và "/" đối với lớp coord. Viết chương trình.

Chương 5
Quá tải toán tử



144
144
2. Tại sao phần dưới đây là cách sử dụng không thích hợp của một toán tử được quá
tải.

coord coord::operator
%
(coord ob)
{
double i;

cout << "Enter a number: ";
cin >> i;
cout << "root of " << i << " is ";
cout << sqr(i);
}
3. Hãy thử thay đổi các kiểu trả về của các hàm toán tử đối với lớp khác lớp coord.
Xem kiểu gì có kết qủa sai ?



III/ Quá tải các toán tử quan hệ và luận lý
Khi quá tải các toán tử quan hệ và luận lý để chúng hoạt động theo cách truyền
thống, sẽ không cần các hàm toán tử trả về một đối tượng của lớp, thay vào đó các
hàm toán tử
trả về một số nguyên để chỉ đúng hay sai
.

•
Quá tải các toán tử "==" và "&&"

Ví dụ 3.1
// Overload the == and && relative to coord class.
#include <iostream.h>

class coord {
int x, y; // coordinate values
public:
coord() { x=0; y=0; }
coord(int i, int j) { x=i; y=j; }

void get_xy(int &i, int &j) { i=x; j=y; }

int operator==(coord ob2)
;
Chương 5
Quá tải toán tử



145
145

int operator&&(coord ob2)
;
};

// Overload the == operator for coord.
int coord::operator==(coord ob2)
{
return x==ob2.x && y==ob2.y;
}

// Overload the && operator for coord.
int coord::operator&&(coord ob2)

{
return (x && ob2.x) && (y && ob2.y);
}
int main()
{
coord o1(10, 10), o2(5, 3), o3(10, 10), o4(0, 0);

if(o1==o2) cout << "o1 same as o2\n";
else cout << "o1 and o2 differ\n";

if(o1==o3) cout << "o1 same as o3\n";
else cout << "o1 and o3 differ\n";

if(o1&&o2) cout << "o1 && o2 is true\n";
else cout << "o1 && o2 is false\n";

if(o1&&o4) cout << "o1 && o4 is true\n";
else cout << "o1 && o4 is false\n";

return 0;
}


Bài tập III

1. Hãy tạo quá tải toán tử "<" và ">" đối với lớp coord. Viết chương trình.
Chương 5
Quá tải toán tử

146
146
IV/ Quá tải toán tử đơn nguyên

Quá tải toán tử đơn nguyên tương tự như toán tử nhò nguyên ngoại trừ
chỉ có một
toán hạng
.

Khi quá tải toán tử đơn nguyên bằng cách dùng hàm thành viên, thì
hàm không có
tham số
. Do chỉ có một toán hạng, nên chính toán hạng này tạo ra lời gọi cho hàm
toán tử.


•
Quá tải toán tử tăng "++" đối với lớp

Ví dụ 4.1
// Overload ++ relative to coord class.
#include <iostream.h>

class coord {
int x, y; // coordinate values

public:
coord() { x=0; y=0; }
coord(int i, int j) { x=i; y=j; }

void get_xy(int &i, int &j) { i=x; j=y; }

coord operator++()
;
};

// Overload ++ for coord class.
coord coord::operator++()
{
x++;
y++;

return
*this
;
}



Chương 5
Quá tải toán tử



147
147
int main()
{
coord o1(10, 10);
int x, y;

++o1
; // increment an object

o1.get_xy(x, y);
cout << "(++o1) X: " << x << ", Y: " << y << "\n";

return 0;
}

•
Với đặc tả mới của C++ (chuẩn ANSI C++), trình biên dòch có thể phân biệt hai
câu lệnh này là khác nhau
++o ; // prefix - tương ứng với cách khai báo ở ví dụ 4.1
o++ ; // posfix
Dạng thứ hai được khai báo như sau
coord coord::operator++(
int notused
) ;
với
notused
luôn luôn được truyền giá trò 0.


•
Với dấu trừ "
-
", vừa là toán tử nhò nguyên lẫn đơn nguyên trong C++. Làm cách
nào có thể quá tải nó sao cho vẫn giữ được cả hai tính chất này đối với lớp do
lập trình viên tạo ra ?

Giải pháp : chỉ cần quá tải nó hai lần, một lần như toán tử nhò nguyên và một lần
như toán tử đơn nguyên.

Ví dụ 4.2
// Overload the - relative to coord class.
#include <iostream.h>

class coord {
int x, y; // coordinate values
public:
coord() { x=0; y=0; }
Chöông 5
Quaù taûi toaùn töû



148
148
coord(int i, int j) { x=i; y=j; }
void get_xy(int &i, int &j) { i=x; j=y; }


coord operator-(coord ob2)
; // binary minus

coord operator-()
; // unary minus
};

// Overload - relative to coord class.
coord coord::operator-(coord ob2)
{
coord temp;

temp.x = x - ob2.x;
temp.y = y - ob2.y;

return
temp
;
}

// Overload unary - for coord class.
coord coord::operator-()
{
x = -x;
y = -y;

return
*this
;
}

int main()
{
coord o1(10, 10), o2(5, 7);
int x, y;

o1 = o1 - o2
; // subtraction

o1.get_xy(x, y);
cout << "(o1-o2) X: " << x << ", Y: " << y << "\n";
Chương 5
Quá tải toán tử



149
149

o1 = - o1
; // negation

o1.get_xy(x, y);
cout << "(-o1) X: " << x << ", Y: " << y << "\n";

return 0;
}


Bài tập IV

1. Hãy quá tải toán tử " " đối với lớp coord. Viết chương trình cho cả hai dạng đứng
trước và đứng sau.

2. Hãy quá tải toán tử "+" đối với lớp coord để cho nó là toán tử nhò nguyên lẫn toán

tử đơn nguyên. Viết chương trình cho cả hai dạng, khi được dùng như toán tử đơn
nguyên hãy thực hiện một giá trò toạ độ âm bất kỳ thành dương.



V/ Hàm toán tử friend

Có thể quá tải một toán tử đối với lớp bằng cách dùng hàm friend, nên nhớ hàm
friend không có con trỏ this.

Với các toán tử nhò nguyên, hàm toán tử friend được truyền cả
hai toán hạng
.
Với các toán tử đơn nguyên, hàm toán tử friend được truyền
một toán hạng
.

Không thể dùng hàm friend để quá tải toán tử gán.


•
Quá tải toán tử "+" bằng cách dùng hàm friend





Chửụng 5
Quaự taỷi toaựn tửỷ

150
150
Vớ duù 5.1
// Overload the + relative to coord class using a friend.
#include <iostream.h>

class coord {
int x, y; // coordinate values
public:
coord() { x=0; y=0; }
coord(int i, int j) { x=i; y=j; }
void get_xy(int &i, int &j) { i=x; j=y; }
friend coord operator+(coord ob1, coord ob2)
;
};

// Overload + using a friend.
coord operator+(coord ob1, coord ob2)
{
coord temp;

temp.x = ob1.x + ob2.x;
temp.y = ob1.y + ob2.y;

return
temp
;
}

int main()
{
coord o1(10, 10), o2(5, 3), o3;
int x, y;


o3 = o1 + o2
; // add two objects - this calls operator+()

o3.get_xy(x, y);
cout << "(o1+o2) X: " << x << ", Y: " << y << "\n";

return 0;
}

Chương 5
Quá tải toán tử



151
151
@ Toán hạng bên trái được truyền cho tham số thứ nhất, toán hạng bên phải được
truyền cho tham số thứ hai.


•
Quá tải một toán tử bằng cách dùng một friend cung cấp đặc điểm quan trọng
mà một hàm thành viên không thể có được. Với hàm toán tử friend, có thể để

cho những đối tượng được sử dụng trong các phép toán có các kiểu đònh sẵn, ở
đó
kiểu đònh sẵn nằm ở bên trái toán tử
.

Trong ví dụ 2.3, chương 5, hàm toán tử thành viên được quá tải
coord coord::operator+(int i)

câu lệnh ob1 = ob2 + 100; là đúng
còn câu lệnh ob1 = 100 + ob2; là sai

Với hàm toán tử friend, có thể đònh nghiã hàm quá tải sao cho toán hạng bên
trái là một đối tượng và toán hạng bên phải là kiểu đònh sẵn. Sau đó, quá tải
toán tử này lần nữa với toán hạng bên trái là kiểu đònh sẵn và toán hạng bên
phải là một đối tượng.

Ví dụ 5.2
// Use friend operator functions to add flexibility.
#include <iostream.h>

class coord {
int x, y; // coordinate values

public:
coord() { x=0; y=0; }
coord(int i, int j) { x=i; y=j; }
void get_xy(int &i, int &j) { i=x; j=y; }
friend coord operator+(coord ob1, int i);
friend coord operator+(int i, coord ob1);
};

Chöông 5
Quaù taûi toaùn töû



152
152
// Overload for ob + int.
coord operator+(
coord ob1, int i
)
{
coord temp;

temp.x = ob1.x + i;
temp.y = ob1.y + i;

return temp;
}

// Overload for int + ob.
coord operator+(
int i, coord ob1
)
{
coord temp;

temp.x = ob1.x + i;
temp.y = ob1.y + i;

return temp;
}

int main()
{
coord o1(10, 10);
int x, y;

o1 = o1 + 10; // object + integer
o1.get_xy(x, y);
cout << "(o1+10) X: " << x << ", Y: " << y << "\n";

o1 = 99 + o1; // integer + object
o1.get_xy(x, y);
cout << "(99+o1) X: " << x << ", Y: " << y << "\n";

return 0;
}
Chương 5
Quá tải toán tử



153
153
@ Do đó hai câu lệnh này lúc này hoàn toàn đúng
ob1 = ob2 + 100;

ob1 = 100 + ob2;


•
Bằng cách truyền toán hạng cho friend như một tham số tham chiếu, những
thay đổi xảy ra bên trong hàm friend có ảnh hưởng đến đối tượng tạo ra lời gọi.
Quá tải toán tử "++" bằng cách dùng hàm friend.

Ví dụ 5.3
// Overload the ++ using a friend.
#include <iostream.h>

class coord {
int x, y; // coordinate values
public:
coord() { x=0; y=0; }
coord(int i, int j) { x=i; y=j; }
void get_xy(int &i, int &j) { i=x; j=y; }

friend coord operator++(coord &ob)
;
};

// Overload ++ using a friend.
coord operator++(coord &ob) // use reference parameter
{
ob.x++;
ob.y++;

return

ob
; // return object generating the call
}

int main()
{
coord o1(10, 10);
int x, y;


++o1
; // o1 is passed by reference
Chương 5
Quá tải toán tử



154
154
o1.get_xy(x, y);
cout << "(++o1) X: " << x << ", Y: " << y << "\n";

return 0;
}

@ Nếu dùng trình biên dòch mới (theo chuẩn ANSI C++), có thể phân biệt giữa các
dạng đứng trước và đứng sau của các toán tử tăng hay giảm khi dùng hàm toán tử
friend. Chỉ cần bổ sung tham số nguyên
notused
khi đònh nghiã dạng đứng sau

(nghiã là toán tử "++" đứng sau toán hạng) .

coord operator++(coord &ob); // prefix ++O
coord operator++(coord &ob,
int notused
); // postfix O++


Bài tập V

1. Hãy quá tải toán tử "-" và "/" đối với lớp coord dùng hàm friend. Viết chương
trình.

2. Quá tải lớp coord để sử dụng các đối tượng coord trong các phép toán mà một giá
trò nguyên được nhân với mỗi toạ độ, cho phép các phép toán dùng thứ tự của nó :
ob * int hoặc int * ob

3. Sử dụng friend, hãy quá tải toán tử " " đối với lớp coord. Viết chương trình cho cả
hai dạng đứng trước và sau.

Chương 5
Quá tải toán tử



155
155
VI/ Toán tử gán
Theo mặc đònh, khi một toán tử gán được áp dụng cho một đối tượng thì một bản sao
từng bit được đặt vào trong đối tượng bên trái.

Tuy nhiên, có những trường hợp mà bản sao từng bit chính xác là không cần. Xem
một số ví dụ trong chương 2, những trường hợp khi một đối tượng sử dụng bộ nhớ.
Trong những trường hợp này, cần phải có một phép gán đặc biệt.
•
Quá tải toán tử "=" trong lớp strtype

Ví dụ 6.1
#include <iostream.h>
#include <string.h>
#include <stdlib.h>

class strtype {
char *p;
int len;
public:
strtype(char *s);
~strtype() {
cout << "Freeing " << (unsigned) p << '\n';
delete [] p;

}
char *get() { return p; }
strtype
&operator=
(strtype &ob);
};

strtype::strtype(char *s)
{
int l;

l = strlen(s)+1;

p = new char [l];
if(!p) {
cout << "Allocation error\n";
exit(1);
Chöông 5
Quaù taûi toaùn töû



156
156
}
len = l;
strcpy(p, s);
}

// Assign an object.

strtype
&
strtype::
operator=
(strtype &ob)

{
// see if more memory is needed
if(len < ob.len) { // need to allocate more memory
delete [] p;
p = new char [ob.len];
if(!p) {
cout << "Allocation error\n";
exit(1);
}
}
len = ob.len;
strcpy(p, ob.p);
return
*this
;
}

int main()
{
strtype a("Hello"), b("There");

cout << a.get() << '\n';
cout << b.get() << '\n';

a = b
; // now p is not overwritten

cout << a.get() << '\n';
cout << b.get() << '\n';

return 0;
}

Chương 5
Quá tải toán tử



157
157
@ Có hai đặc điểm với hàm operator=() trong ví dụ này
+ nó có một tham số tham chiếu
+ nó trả về tham chiếu chứ không phải một đối tượng


Bài tập VI

1. Cho khai báo lớp dưới đây, hãy thêm vào các chi tiết để tạo nên một kiểu mảng
"an toàn". Sau đó, hãy quá tải toán tử gán để cho bộ nhớ được cấp phát của mảng
không bò hủy tình cờ.

class dynarray {
int *p;

int size;
public:
dynarray(int s); // pass size of array in s
int &put(int i); // return reference to element i
int get(int i); // return value of element i
// create operator=() function

};
















Chương 5
Quá tải toán tử



158

158
Bài tập chương 5



1. Quá tải các toán tử >> và << đối với lớp coord để cho có các kiểu phép toán sau
đây :
ob << integer ;
ob >> integer ;
Viết chương trình làm cho các toán tử trên nâng các giá trò x và y lên một đại lượng
được chiû rõ.

2. Cho lớp
class three_d {
int x, y, z;
public:
three_d(int i, int j, int k)
{
x = i; y = j; z = k;
}
three_d() { x=0; y=0; z=0; }
void get(int &i, int &j, int &k)
{
i = x; j = y; k = z;
}
};
Hãy quá tải các toán tử +, -, ++ và đối với lớp này. Đối với các toán tử tăng và
giảm chiû quá tải theo dạng đứng trước. Viết chương trình thực hiện các yêu cầu sau :

- khai báo các đối tượng : three_d o1(6,8,10), o2(3,4,5), o3;

- thực hiện các phép toán : o3 = o1 + o2;
o3 = o1 - o2;
++o1 ;
o1;
- xuất nội dung x, y, z của các đối tượng trên.

3. Thực hiện lại bài tập 2 dưới dạng tham số tham chiếu đối với các hàm toán tử.
Dùng hàm friend đối với các toán tử tăng và giảm.
Chương 5
Quá tải toán tử



159
159

4. Viết chương trình thực hiện quá tải toán tử + đối với lớp three_d để cho nó nhận
các kiểu phép toán sau : ob + double; double + ob;

5. Viết chương trình thực hiện quá tải các toán tử ==, !=, và // đối với lớp three_d.

6. Viết chương trình tạo lớp strtype để cho phép các kiểu toán tử sau :
* ghép chuổi bằng cách dùng toán tử +
* gán chuổi bằng cách dùng toán tử =
* so sánh chuổi bằng cách dùng các toán tử > , < và ==

có thể dùng chuổi có độ dài cố đònh. Trong đó :
- một biến chuổi s[80] có dạng private
- hàm tạo không đối số, thực hiện việc khởi tạo chuổi s là NULL
- hàm tạo có một đối số *p, thực hiện việc chép nội dung chuổi p cho s

- hàm char *get() trả về giá trò của chuổi s

7. Hãy bổ sung các hàm toán tử cần thiết vào chương trình sau.
* Toán tử quá tải + cộng mỗi phần tử của toán hạng.
* Toán tử quá tải - trừ phần tử toán hạng bên trái với mỗi phần tử của toán hạng bên
phải.
* Toán tử quá tải == trả về giá trò đúng nếu mỗi phần tử của mỗi toán hạng là giống
nhau và trả về giá trò sai nếu ngược lại.

#include <iostream>

class array {
int nums[10];
public:
array();
void set(int n[10]);
void show();
array operator+(array ob2);
array operator-(array ob2);
int operator==(array ob2);
};