Toán tử 2 ngôi (binary) nếu được cài đặt là hàm thành viên thì cần bao nhiêu tham số?

Bài viết được sự cho phép của tác giả Khiêm Lê

Để đọc hiểu bài này tốt nhất, bạn nên có kiến thức về:

  C Token là gì? Cú pháp trong lập trình C/C++

Nếu bạn đã học qua lập trình C++ cơ bản, chắc chắc rằng trong hầu hết các bài tập về C++, bạn đều sử dụng các toán tử số học như cộng, trừ, nhân, chia. Hầu hết các toán tử đó đều được thực hiện trên toán hạng có kiểu dữ liệu cơ bản như int, float, double…

int a = 5; int b = 4; int c = a + b; // = 9

Vậy nếu như bạn muốn thực hiện các toán tử đó đối với toán hạng có kiểu dữ liệu bạn tự định nghĩa thì làm sao?

PhanSo ps1[1, 2]; PhanSo ps2[2, 3]; // Làm sao để có thể cộng hai phân số? PhanSo ketQua = ps1 + ps2;

Đây chính là lúc chúng ta sử dụng nạp chồng toán tử. Vậy hãy cùng tìm hiểu xem nạp chồng toán tử là gì và cách nạp chồng toán tử như thế nào.

Cũng tương tự như nạp chồng hàm [overload function], bạn có thể định nghĩa nhiều hàm có cùng tên, nhưng khác tham số truyền vào, nạp chồng toán tử cũng tương tự.

Nạp chồng toán tử [overload operator] là bạn định nghĩa lại toán tử đã có trên kiểu dữ liệu người dùng tự định nghĩa để dể dàng thể hiện các câu lệnh trong chương trình.

Ví dụ như bạn định nghĩa phép cộng cho kiểu dữ liệu phân số thì sẽ thực hiện cộng hai phân số rồi trả về một phân số mới. So với việc thực hiện gọi hàm, việc overload toán tử sẽ làm cho câu lệnh ngắn gọn, dễ hiểu hơn.

PhanSo ps1[1, 2]; PhanSo ps2[2, 3]; PhanSo ketQua; // Dùng hàm ketQua = ps1.cong[ps2]; // Dùng Overload operator ketQua = ps1 + ps2; // 7/6

Về bản chất, việc thực hiện các toán tử cũng tương đương với việc gọi hàm, ví dụ:

PhanSo a[1, 2]; PhanSo b[2, 3]; PhanSo ketQua = a + b; // Tương đương với PhanSo ketQua = a.cong[b];

Nếu bạn thực hiện toán tử trên hai toán hạng có kiểu dữ liệu cơ bản [float, double, int…], trình biên dịch sẽ tìm xem phiên bản nạp chồng toán tử nào phù hợp với kiểu dữ liệu đó và sử dụng, nếu không có sẽ báo lỗi.

Ngược lại nếu là kiểu dữ liệu tự định nghĩa như struct, class, trình biên dịch sẽ tìm xem có phiên bản nạp chồng toán tử nào phù hợp không? Nếu có thì sẽ sử dụng toán tử đó, ngược lại thì sẽ cố gắng chuyển đổi kiểu dữ liệu của các toán hạng đó sang kiểu dữ liệu có sẵn để thực hiện phép toán, không được sẽ báo lỗi.

+	–	*	/	%	^	&	|
~	!	=		+=	-=	*=
/=	%=	^=	&=	|=		>>=
	[]	[]	new	delete
new[]	delete[]

Bảng các toán tử có thể overload được.

Vậy ta chỉ có một số toán tử sau không overload được:

• Toán tử . [chấm]
• Toán tử phạm vi ::
• Toán tử điều kiện ?:
• Toán tử sizeof

Một số lưu ý:

• Các toán tử một ngôi [–, ++] có thể đứng trước hoặc sau toán hạng
• Một số toán tử có thể làm toán tử một ngôi hoặc hai ngôi như toán tử *
• Toán tử chỉ mục [[…]] là toán tử hai ngôi
• Các từ khóa new và delete cũng được xem là toán tử nên có thể được overload

Như đã giới thiệu, bản chất việc dùng toán tử là lời gọi hàm, do đó chúng ta overload toán tử cũng giống overload hàm, vậy chúng ta sẽ overload hàm nào? Chúng ta sẽ overload hàm có tên là “operator@”, với @ là toán tử cần overload [+, -, *, /…], kiểu trả về của hàm chính là lớp đó.

Có hai loại là hàm cục bộ [dùng phương thức của lớp] và hàm toàn cục [dùng hàm bạn]. Chúng ta sẽ lần lượt tìm hiểu cách overload toán tử bằng cả hai cách.

Đối với hàm cục bộ hay còn gọi là phương thức của lớp, số tham số sẽ ít hơn hàm toàn cục một tham số vì tham số đầu tiên mặc định chính là toán hạng đầu tiên. Vậy, đối với toán tử hai ngôi, ta chỉ cần truyền một tham số cho hàm, chính là toán hạng thứ hai. Ví dụ:

class PhanSo { int tu; int mau; public: PhanSo[] : tu[0], mau[1] {} PhanSo operator+[const PhanSo &ps] // overload toán tử + { PhanSo kq; kq.tu = this->tu * ps.mau + ps.tu * this->mau; kq.mau = this->mau * ps.mau; return kq; } };

Sau khi overload toán tử, bạn có thể sử dụng nó trên kiểu dữ liệu bạn đã định nghĩa:

PhanSo ps1[1, 2]; PhanSo ps2[2, 3]; PhanSo ps3 = ps1 + ps2; // = 1/2 + 2/3

Giờ chúng ta hãy xem một ví dụ khác, overload toán tử cộng một phân số với một số nguyên.

class PhanSo { // properties & methods PhanSo operator+[const int &i] { PhanSo kq; kq.tu = this->tu + i * this->mau; return kq; } } // Sử dụng PhanSo ps1[1, 2]; PhanSo ps2 = ps1 + 2; // = 5/2

Do toán tử overload theo cách này là phương thức, được gọi từ một đối tượng, do đó mặc định toán hạng đầu tiên phải là toán hạng có kiểu dữ liệu của lớp đó, điều này cũng có nghĩa là bạn phải đặt toán hạng có kiểu dữ liệu của lớp đó đầu tiên rối mới đến toán hạng tiếp theo. Và đối với các kiểu dữ liệu có sẵn, ta không thể truy cập vào các lớp định nghĩa nên chúng, do đó ta không thể overload operator của chúng được. Vậy để giải quyết điều này thì làm như thế nào? Ta sẽ sử dụng hàm toàn cục.

Thay vì đối với việc toán hạng đầu tiên luôn phải có kiểu là lớp nào đó, chúng ta sẽ sử dụng hàm bạn để có thể tự do lựa chọn thứ tự của các toán hạng. Ví dụ như bạn muốn 1 + ps1, ps1 + 1 đều được chứ không nhất thiết phải là ps1 + 1 nữa. Chúng ta cài đặt với hàm bạn tương tự như sau:

class PhanSo { // properties & methods friend PhanSo operator+[const PhanSo &ps, const int &i]; } PhanSo operator+[const PhanSo &ps, const int &i] { PhanSo kq; kq.tu = ps.tu + i * ps.mau; return kq; } // Sử dụng PhanSo ps1[1, 2]; PhanSo ps2 = ps1 + 2; // = 5/2

Khá là giống với overload toán tử theo cách dùng phương thức phải không? Vậy nếu muốn đổi thứ tự toán hạng thì phải làm sao, đơn giản đổi thứ tự tham số là được:

PhanSo operator+[const int &i, const PhanSo &ps] // hàm bạn của class PhanSo { return ps + i; }

Có hai loại chuyển kiểu là chuyển kiểu bằng toán tử chuyển kiểu và chuyển kiểu bằng constructor

Như đã trình bày trong phần cơ chế, nếu không tìm thấy phiên bản nạp chồng toán tử nào phù hợp với kiểu dữ liệu của toán hạng, trình biên dịch sẽ chuyển đối toán hạng sang kiểu dữ liệu cơ bản để tính toán. Vậy chúng ta sẽ cần overload toán tử chuyển kiểu để trình biên dịch có thể chuyển kiểu dữ liệu ta định nghĩa sang kiểu dữ liệu cơ bản.

Ví dụ như mình muốn chuyển phân số về số thực, mình sẽ overload toán tử chuyển kiểu float:

// Cú pháp operator T[] { return x; // x có kiểu dữ liệu là T } // Ví dụ overload toán tử chuyển kiểu float class PhanSo { // properties & methods operator float[]; } PhanSo::operator float[] { return [float]this->tu / this->mau; }

Lúc này, ta sẽ có thể thực hiện chuyển kiểu dữ liệu:

PhanSo ps1[1, 2]; PhanSo ps2[2, 3]; float a = ps1 + ps2; cout > và [istream &in, PhanSo &ps]; } istream &operator>>[istream &in, PhanSo &ps] { cout > ps.tu; cout > ps.mau; return in; }

Như vậy toán tử nhập đã được overload cho lớp phân số, bây giờ khi gọi toán tử nhập chúng ta sẽ được kết quả sau:

PhanSo ps; cin >> ps; // Tu: 1 // Mau: 2

Đối với toán tử nhập cũng tương tự, chúng ta cũng thực hiện tương tự như sau:

class PhanSo { // properties & methods friend ostream &operator