Nạp chồng toán tử trong C++: tự định nghĩa +, == và <<

Để kiểu của bạn dùng như kiểu có sẵn

Bạn đã biết std::string cho phép viết a + b để nối chuỗi và cout << s để in ra. Đó không phải mẹo đặc biệt nào của trình biên dịch: chúng là các hàm bình thường với cái tên hơi lạ. Nạp chồng toán tử (operator overloading) là tính năng cho phép các lớp của bạn dùng cùng cú pháp đó, để một kiểu Vector2 hay Money có thể cộng, so sánh và in ra y như một int.

Cơ chế này rất đơn giản khi bạn đã thấy nó: một biểu thức như a + b chỉ là cách viết tắt. Trình biên dịch viết lại nó thành lời gọi tới hàm tên operator+ và tìm một hàm khớp với kiểu của các toán hạng. Định nghĩa hàm đó cho lớp của bạn là a + b bỗng chạy được. Đây thực chất là một dạng đặc biệt của nạp chồng hàm: các quy tắc phân giải tên ở đó vẫn áp dụng, chỉ khác là tên có hình dạng toán tử.

#include <iostream>
using namespace std;

struct Vector2 {
    double x, y;
};

// a + b becomes operator+(a, b)
Vector2 operator+(const Vector2& a, const Vector2& b) {
    return Vector2{a.x + b.x, a.y + b.y};
}

int main() {
    Vector2 p{1, 2};
    Vector2 q{3, 4};
    Vector2 r = p + q;          // calls operator+
    cout << r.x << ", " << r.y << "\n";  // 4, 6
}

Lưu ý hàm nhận cả hai toán hạng bằng const&: phép tính số học không nên sửa đầu vào, và tham chiếu giúp tránh sao chép. Hàm trả về một Vector2 mới theo giá trị: p + q phải cho ra một kết quả mới mà không đụng tới p hay q, giống như 2 + 3 không làm thay đổi 2.

Hàm thành viên và hàm không thành viên

Có hai chỗ để định nghĩa toán tử: là một thành viên của lớp, hoặc là một hàm tự do (không thành viên). Khi là thành viên, toán hạng bên trái là this ngầm định, nên một toán tử hai ngôi chỉ nhận một tham số tường minh:

#include <iostream>
using namespace std;

class Money {
    long cents;
public:
    Money(long c) : cents(c) {}

    // member: left operand is *this, right operand is the parameter
    Money operator+(const Money& other) const {
        return Money(cents + other.cents);
    }

    long value() const { return cents; }
};

int main() {
    Money a(150), b(99);
    Money total = a + b;        // a.operator+(b)
    cout << total.value() << "\n";  // 249
}

Chữ const sau danh sách tham số rất quan trọng: a + b không nên sửa a, nên hàm thành viên được đánh dấu const. Hãy dùng dạng thành viên cho các toán tử gắn liền với toán hạng bên trái và không cần chuyển đổi kiểu cho nó: +=, [], (), ->, và các toán tử một ngôi như -x hay ++x.

Điểm vướng của dạng thành viên: toán hạng bên trái không thể được chuyển đổi kiểu. Với operator+ thành viên ở trên, a + 50 chạy được (50 được chuyển thành Money ở vế phải), nhưng 50 + a thì không biên dịch được: toán hạng bên trái 50 là một int, và bạn không thể thêm hàm thành viên cho int. Một toán tử không thành viên giải quyết được chuyện này vì cả hai toán hạng đều là tham số tường minh và đều chuyển đổi được:

#include <iostream>
using namespace std;

class Money {
    long cents;
public:
    Money(long c) : cents(c) {}
    long value() const { return cents; }
    // grant the free function access to the private field
    friend Money operator+(const Money& a, const Money& b);
};

Money operator+(const Money& a, const Money& b) {
    return Money(a.cents + b.cents);
}

int main() {
    Money a(150);
    Money total = 50 + a;       // 50 converts to Money(50); now symmetric
    cout << total.value() << "\n";  // 200
}

Quy tắc chung: làm các toán tử hai ngôi đối xứng (+, ==, *) thành hàm không thành viên để chuyển đổi kiểu hoạt động ở cả hai phía; làm các toán tử phải sửa đổi hoặc gắn với toán hạng bên trái (+=, [], =) thành hàm thành viên.

Nạp chồng toán tử stream

Toán tử được nạp chồng nhiều nhất là << để in ra. Bạn không thể biến nó thành thành viên của lớp, vì toán hạng bên trái là một std::ostream (như cout), không phải kiểu của bạn, và bạn không sở hữu ostream. Vì vậy nó luôn là hàm không thành viên, nhận stream bằng tham chiếu không const và trả về chính stream đó:

#include <iostream>
using namespace std;

struct Point {
    int x, y;
};

// left operand is the stream; return it so calls can chain
ostream& operator<<(ostream& os, const Point& p) {
    os << "(" << p.x << ", " << p.y << ")";
    return os;
}

int main() {
    Point p{3, 7};
    cout << "p = " << p << "\n";   // p = (3, 7)
}

Hai chi tiết giúp cách này hoạt động. Stream được truyền vào và trả về theo tham chiếu (ostream&): stream không sao chép được, và việc trả về chính stream đó cho phép bạn viết nối tiếp cout << "p = " << p << "\n". Mỗi << trả về stream để << tiếp theo có thứ để gắn vào. Quên return os; là chuỗi lời gọi bị đứt.

Toán tử so sánh

Để so sánh các đối tượng của bạn bằng ==, < và các toán tử cùng họ, hãy nạp chồng các toán tử so sánh. Trước C++20 bạn phải tự viết từng toán tử; cái bẫy chính là operator< phải trả về bool và định nghĩa một thứ tự nhất quán:

#include <iostream>
using namespace std;

struct Version {
    int major, minor;
};

bool operator==(const Version& a, const Version& b) {
    return a.major == b.major && a.minor == b.minor;
}

bool operator<(const Version& a, const Version& b) {
    if (a.major != b.major) return a.major < b.major;
    return a.minor < b.minor;        // tie-break on minor
}

int main() {
    Version v1{1, 4}, v2{1, 9};
    cout << (v1 == v2) << "\n";   // 0
    cout << (v1 < v2) << "\n";    // 1
}

Tự viết cả sáu phép so sánh (==, !=, <, <=, >, >=) vừa tẻ nhạt vừa dễ sai. C++20 bổ sung toán tử so sánh ba chiều <=> (còn gọi là "spaceship"). Đặt nó và == ở dạng mặc định sẽ sinh ra mọi phép so sánh cho bạn:

#include <compare>
#include <iostream>
using namespace std;

struct Version {
    int major, minor;
    auto operator<=>(const Version&) const = default;
    bool operator==(const Version&) const = default;
};

int main() {
    Version v1{1, 4}, v2{1, 9};
    cout << (v1 < v2)  << "\n";   // 1
    cout << (v1 >= v2) << "\n";   // 0
}

= default bảo trình biên dịch so sánh các thành viên theo thứ tự khai báo, đúng với thứ tự từ điển mà bạn sẽ tự viết. Hãy ưu tiên cách này trên các trình biên dịch hiện đại.

Toán tử gán và những cái bẫy

operator= (gán sao chép) là trường hợp đặc biệt: trình biên dịch tự sinh một phiên bản cho bạn, và với các lớp đơn giản thì bản mặc định đó là đúng. Bạn chỉ cần tự viết khi lớp quản lý một tài nguyên, như bộ nhớ thô hay một file handle, nơi việc sao chép từng thành viên một sẽ sai. Signature chuẩn trả về *this theo tham chiếu để phép gán có thể nối tiếp (a = b = c):

#include <iostream>
using namespace std;

class Buffer {
    int* data;
    int size;
public:
    Buffer(int n) : data(new int[n]), size(n) {}
    ~Buffer() { delete[] data; }

    Buffer& operator=(const Buffer& other) {
        if (this == &other) return *this;   // guard against self-assignment
        delete[] data;                      // free what we held
        size = other.size;
        data = new int[size];               // allocate fresh
        for (int i = 0; i < size; ++i) data[i] = other.data[i];
        return *this;                       // enable a = b = c
    }
    int length() const { return size; }
};

int main() {
    Buffer a(3), b(5);
    a = b;
    cout << a.length() << "\n";   // 5
}

Có hai cái bẫy trong hàm ngắn này. Thứ nhất là kiểm tra tự gán if (this == &other): thiếu nó, a = a sẽ delete[] data rồi đọc từ other.data vừa bị giải phóng, đó là undefined behavior. Thứ hai, thứ tự rất quan trọng: trong phiên bản tự viết, bạn không được xóa bộ đệm cũ trước khi đã sao chép an toàn bộ đệm mới (cách cài đặt thực tế thường cấp phát trước, hoặc dùng idiom copy-and-swap, để nếu cấp phát thất bại thì đối tượng vẫn nguyên vẹn).

Một cái bẫy rộng hơn: đừng nạp chồng toán tử theo những cách gây bất ngờ. Một operator+ lén sửa toán hạng bên trái, hay một operator== không đối xứng, sẽ làm mọi người đọc code bối rối và phá vỡ code của thư viện chuẩn vốn giả định ý nghĩa thông thường. Chỉ nạp chồng toán tử khi phép toán thật sự "giống phép cộng" hay "giống phép so sánh bằng" đối với kiểu của bạn.

Tiếp theo: access specifier

Để ý rằng mọi ví dụ đều giữ các thành viên dữ liệu ở private và chỉ để lộ hành vi qua một bề mặt public nhỏ: hàm khởi tạo, toán tử và vài phương thức. Ranh giới giữa những gì thế giới bên ngoài nhìn thấy và những gì được giấu bên trong lớp do các access specifier kiểm soát: public, private và protected. Tiếp theo, chúng ta sẽ xem chính xác mỗi loại cho phép những gì, vì sao dữ liệu private cùng phương thức public là mặc định cho tính đóng gói tốt, và protected khớp vào kế thừa như thế nào.