Operator Overloading C++: Operator +, ==, dan << Buatan Sendiri

Membuat Tipemu Terasa Seperti Tipe Bawaan

Kamu sudah tahu bahwa std::string membuatmu bisa menulis a + b untuk menyambung dan cout << s untuk mencetak. Itu bukan trik khusus compiler; keduanya adalah fungsi biasa dengan nama yang unik. Operator overloading adalah fitur yang membuat class milikmu bisa memakai sintaks yang sama, sehingga tipe Vector2 atau Money bisa dijumlahkan, dibandingkan, dan dicetak persis seperti int.

Mekanismenya sederhana begitu kamu melihatnya: ekspresi seperti a + b hanyalah singkatan. Compiler menulis ulang ekspresi itu menjadi pemanggilan fungsi bernama operator+ dan mencari fungsi yang cocok dengan tipe operannya. Definisikan fungsi itu untuk class-mu, dan a + b tiba-tiba berfungsi. Ini sebenarnya bentuk khusus dari function overloading: aturan pencarian nama yang sama berlaku, hanya saja dengan nama berbentuk operator.

#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
}

Perhatikan bahwa fungsi itu menerima kedua operan lewat const&: aritmetika tidak seharusnya mengubah input-nya, dan referensi menghindari penyalinan. Fungsi itu mengembalikan Vector2 yang baru by value: p + q harus menghasilkan hasil baru tanpa menyentuh p atau q, sama seperti 2 + 3 tidak mengubah 2.

Member vs Non-Member

Ada dua tempat untuk mendefinisikan operator: sebagai member class, atau sebagai fungsi bebas (non-member). Sebagai member, operan kirinya adalah this yang implisit, jadi operator biner hanya menerima satu parameter eksplisit:

#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
}

const setelah daftar parameter itu penting: a + b tidak seharusnya mengubah a, jadi member-nya ditandai const. Pakai bentuk member untuk operator yang pada dasarnya terikat pada operan kiri dan tidak butuh konversi padanya: +=, [], (), ->, dan operator unary seperti -x atau ++x.

Masalah dengan member: operan kirinya tidak bisa dikonversi. Dengan operator+ member di atas, a + 50 berfungsi (50 dikonversi menjadi Money untuk sisi kanan), tetapi 50 + a tidak bisa dikompilasi: operan kiri 50 adalah int, dan kamu tidak bisa menambahkan member function ke int. Operator non-member memperbaikinya karena kedua operan adalah parameter eksplisit dan keduanya bisa dikonversi:

#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
}

Patokannya: jadikan operator biner yang simetris (+, ==, *) sebagai non-member supaya konversi berfungsi di kedua sisi; jadikan operator yang harus mengubah atau terikat pada operan kiri (+=, [], =) sebagai member.

Overloading Operator Stream

Operator yang paling sering di-overload adalah << untuk mencetak. Kamu tidak bisa menjadikannya member class-mu, karena operan kirinya adalah std::ostream (seperti cout), bukan tipemu, dan kamu bukan pemilik ostream. Jadi operator ini selalu non-member yang menerima stream lewat referensi non-const dan mengembalikannya:

#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)
}

Ada dua detail yang membuatnya berfungsi. Stream diteruskan dan dikembalikan by reference (ostream&): stream tidak bisa disalin, dan mengembalikan stream yang sama itulah yang membuatmu bisa merangkai cout << "p = " << p << "\n". Setiap << mengembalikan stream sehingga << berikutnya punya sesuatu untuk diikat. Lupa menulis return os; dan rangkaiannya rusak.

Operator Perbandingan

Untuk membandingkan objekmu dengan ==, <, dan kawan-kawannya, overload operator perbandingan. Sebelum C++20 kamu menulis masing-masing secara manual; jebakan utamanya adalah operator< harus mengembalikan bool dan mendefinisikan urutan yang konsisten:

#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
}

Menulis keenam perbandingan (==, !=, <, <=, >, >=) secara manual itu membosankan dan rawan salah. C++20 menambahkan operator perbandingan tiga arah <=> (si "spaceship"). Menjadikannya default bersama == membuat semua perbandingan dibuatkan untukmu:

#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 menyuruh compiler membandingkan member sesuai urutan deklarasinya, yang persis merupakan urutan leksikografis yang akan kamu tulis secara manual. Utamakan cara ini di compiler modern.

Operator Penugasan dan Jebakannya

operator= (copy assignment) itu istimewa: compiler membuatkannya untukmu, dan untuk class sederhana versi default itu sudah benar. Kamu hanya perlu menulis versimu sendiri saat class-mu mengelola sebuah resource, seperti memori mentah atau file handle, ketika menyalin member satu per satu akan salah. Signature kanonisnya mengembalikan *this by reference supaya penugasan bisa dirangkai (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
}

Ada dua jebakan di fungsi pendek ini. Pertama, pengecekan self-assignment if (this == &other): tanpa itu, a = a akan melakukan delete[] data lalu membaca dari other.data yang baru saja dibebaskan, yaitu undefined behavior. Kedua, urutannya penting: di versi buatan sendiri kamu tidak boleh menghapus buffer lama sebelum berhasil menyalin yang baru dengan aman (implementasi sungguhan sering mengalokasikan dulu, atau memakai idiom copy-and-swap, supaya alokasi yang gagal tidak merusak objeknya).

Jebakan yang lebih luas: jangan meng-overload operator dengan cara yang mengejutkan. operator+ yang diam-diam mengubah operan kirinya, atau operator== yang tidak simetris, akan membingungkan setiap pembaca dan merusak kode standard library yang mengandalkan arti yang biasa. Overload operator hanya saat operasinya memang "seperti penjumlahan" atau "seperti kesamaan" untuk tipemu.

Berikutnya: Access Specifier

Perhatikan bagaimana setiap contoh menjaga data member-nya tetap private dan membuka perilakunya lewat antarmuka public yang kecil: constructor, operator, dan beberapa method. Batas antara apa yang terlihat oleh dunia luar dan apa yang tersembunyi di dalam class diatur oleh access specifier: public, private, dan protected. Berikutnya kita akan melihat persis apa yang diizinkan masing-masing, kenapa data private dengan method public adalah default untuk enkapsulasi yang baik, dan bagaimana protected berperan dalam pewarisan.