Quá tải toán tử (Operator Overloading)

Toán tử là 1 loại phương thức đặc biệt của lớp đối tượng nhằm thể hiện trực quan khi được gọi thực hiện 1 phép toán nào đó trên lớp. C/ C++ đã cài đặt sẳn toán tử cho các kiểu dữ liệu cơ bản như int, float,… Đối với các kiểu dữ liệu tự định nghĩa, C++ cho phép lập trình viên định nghĩa các toán tử thao tác trên các đối tượng thuộc kiểu dữ liệu mới này. Người ta gọi đó là quá tải toán tử (operator overloading).

Mục đích của việc quá tải toán tử là giúp cho chương trình trong gọn gàng, dễ hiểu hơn, thay vì phải gọi phương thức.

Ví dụ: Ta có 2 biến a, b là đối tượng của lớp CphanSo. Để tính tổng 2 phân số này, ta có thể sử dụng 2 cách:

• Sử dụng phương thức cộng: CPhanSo c = a.Cong(b);
• Quá tải toán tử cộng cho lớp CPhanSo: CPhanSo c = a + b;

Rỏ ràng, khi sử dụng phương pháp quá tải toán tử, chương trình nhìn gọn gàng và trực quan hơn hẳn.

Có nhiều cách để phân loại toán tử, nếu dự vào số lượng toán hạng thì các toán tử trong C++ được chia thành 2 dạng sau:

• Toán tử đơn: Có 1 toán hạng
  • Dạng tiền tố: ++, --, !, &, …
  • Dạng hậu tố: ++, --, …
• Toán tử đôi: Có 2 toán hạng

Nếu phân loại toán tử dựa vào chức năng thì các toán tử trong C++ được chia thành các loại sau:

• Toán tử gán: =
• Các toán tử số học: +, -, *, /, %
• Các toán tử gán phức hợp: +=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=
• Các toán tử tăng/ giảm: ++, --
• Các toán tử quan hệ: ==, !=, >, =, <=
• Các toán tử logic: !, &&, ¦¦
• Toán tử điều kiện: ?
• Các toán tử thao tác bit: &, |, ^, ~, <>
• Các toán tử ép kiểu: (int), (float), ...
• Một số toán tử khác: (), [ ], ->, ...

C++ cho phép lập trình viên quá tải toán tử cho kiểu dữ liệu tự định nghĩa, tuy nhiên không phải toán tử nào cũng được phép quá tải. C++ chỉ cho quá tải các toán tử sau:

+ , - , * , / , %  , += , -= , *= , /= > , >= , < , <= , == , != && , ¦¦ , ++ , -- , -> , () , [] new , new[] , delete , delete[]

Đối với các toán tử . , .*, :: , :? , typeid , sizeof, C++ không cho phép quá tải các toán tử này.

Cú pháp khai báo và định nghĩa 1 toán tử:

KDL_TraVe          operator@(Danh_Sach_Doi_So)
{
//Thân hàm
}

Việc khai báo và định nghĩa toán tử cũng tương tự như khai báo và định nghĩa 1 hàm  bình thường. Chỉ khác là ta sử dụng operator@ thay cho tên hàm (với @ là toán tử cần được quá tải). Danh sách đối số phụ thuộc vào toán tử @ là toán tử đơn hay đôi và toán tử được khai báo dưới dạng là 1 hàm toàn cục hay là 1 phương thức của lớp.

Dạng	Phương thức của lớp	Hàm toàn cục
A@B	operator@(B)	operator@(A, B)
@A	operator@()	operator@(A)
A@	operator@(int)	operator@(A, int)

Một số chú ý khi quá tải toán tử:

• Khi phép toán có toán hạng thứ 1 là 1 đối tượng thuộc lớp thì có thể dùng phương thức của lớp hoặc hàm toàn cục.
• Nếu toán hạng thứ 1 không phải là đối tượng thuộc lớp thì ta phải dùng hàm toàn cục.
• Các toán tử = , [] , () , -> bắt buộc phải khai báo là phương thức của lớp.

Ví dụ minh họa quá tải toán tử

class CPhanSo
{
private:
 int tu;
 int mau;
public:
 CPhanSo operator+(CPhanSo);
 CPhanSo& operator+=(CPhanSo);
 CPhanSo& operator++(int); //Toán tử++ dạng hậu tố
 friend CPhanSo operator-(CPhanSo,CPhanSo); //Khai báo dạng hàm toàn cục
};
CPhanSo CPhanSo::operator+(CPhanSo a)
{
 CPhanSo tong;
 tong.tu = tu*a.mau + mau*a.tu;
 tong.mau = mau*a.mau;
 return tong;
}
CPhanSo& CPhanSo::operator+=(CPhanSo a)
{
 tu = tu*a.mau + mau*a.tu;
 mau = mau*a.mau;
 return (*this);
}
CPhanSo& CPhanSo::operator++(int)
{
 tu += mau;
 return (*this);
}
CPhanSo operator-(CPhanSo A,CPhanSo B)
{
 CPhanSo hieu;
 hieu.tu = A.tu*B.mau - A.mau*B.tu;
 hieu.mau = A.mau*B.mau;
 return hieu;
}

Trong ví dụ trên, cần lưu ý những điểm sau:

• Với toán tử ++ được khai báo như trên thì với biến A thuộc lớp CPhanSo, nếu ta viết ++A thì chương trình sẽ báo lỗi, ta chỉ có thể viết A++ (vì ta chỉ mới quá tải toán tử hậu tố ++ cho lớp CPhanSo).
• Con trỏ this: dùng để lưu địa chỉ của đối tượng mà ta đang xử lý.
• Nếu 1 hàm (hoặc lớp) là được khai báo là friend đối với 1 lớp thì hàm (hoặc lớp) này có thể truy xuất tới bất cứ thành phần nào của đối tượng thuộc lớp.