העמסת אופרטורים ב-C++: אופרטורים +, == ו-<< משלכם

להרגיש כמו טיפוס מובנה

אתם כבר יודעים ש-std::string מאפשר לכתוב a + b כדי לשרשר ו-cout << s כדי להדפיס. אלה לא טריקים מיוחדים של הקומפיילר: אלה פונקציות רגילות עם שמות משונים. העמסת אופרטורים היא התכונה שמאפשרת למחלקות שלכם להתחבר לאותו תחביר, כך שטיפוס Vector2 או Money יכול להתחבר, להשתוות ולהודפס בדיוק כמו int.

המנגנון פשוט ברגע שרואים אותו: ביטוי כמו a + b הוא קיצור. הקומפיילר כותב אותו מחדש כקריאה לפונקציה בשם operator+ ומחפש אחת שמתאימה לטיפוסי האופרנדים. הגדירו את הפונקציה הזו למחלקה שלכם, ופתאום a + b עובד. זו בעצם צורה מיוחדת של העמסת פונקציות: אותם כללי פענוח שמות חלים גם כאן, רק עם שמות בצורת אופרטורים.

#include <iostream>
using namespace std;

struct Vector2 {
    double x, y;
};

// a + b הופך ל-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;          // קורא ל-operator+
    cout << r.x << ", " << r.y << "\n";  // 4, 6
}

שימו לב שהפונקציה מקבלת את שני האופרנדים כ-const&: חשבון לא אמור לשנות את הקלטים שלו, והפניות חוסכות העתקה. היא מחזירה Vector2 חדש לפי ערך: p + q חייב להפיק תוצאה חדשה בלי לגעת ב-p או ב-q, בדיוק כמו ש-2 + 3 לא משנה את 2.

פונקציית איבר מול פונקציה חיצונית

יש שני מקומות להגדיר אופרטור: כאיבר של המחלקה או כפונקציה חופשית (חיצונית). כאיבר, האופרנד השמאלי הוא ה-this המרומז, ולכן אופרטור בינארי מקבל רק פרמטר מפורש אחד:

#include <iostream>
using namespace std;

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

    // איבר: האופרנד השמאלי הוא *this, האופרנד הימני הוא הפרמטר
    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 שאחרי רשימת הפרמטרים חשוב: a + b לא אמור לשנות את a, ולכן האיבר מסומן const. השתמשו בצורת האיבר לאופרטורים שקשורים מטבעם לאופרנד השמאלי ולא צריכים המרות עליו: +=, [], (), ->, ואופרטורים אונריים כמו -x או ++x.

הבעיה עם איברים: אי אפשר להמיר את האופרנד השמאלי. עם ה-operator+ שהוא איבר למעלה, a + 50 עובד (50 מומר ל-Money בצד הימני), אבל 50 + a לא מתקמפל: האופרנד השמאלי 50 הוא int, ואי אפשר להוסיף פונקציית איבר ל-int. אופרטור חיצוני פותר את זה, כי שני האופרנדים הם פרמטרים מפורשים ושניהם יכולים לעבור המרה:

#include <iostream>
using namespace std;

class Money {
    long cents;
public:
    Money(long c) : cents(c) {}
    long value() const { return cents; }
    // נותנים לפונקציה החופשית גישה לשדה הפרטי
    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 מומר ל-Money(50); עכשיו זה סימטרי
    cout << total.value() << "\n";  // 200
}

כלל אצבע: הפכו אופרטורים בינאריים סימטריים (+, ==, *) לחיצוניים כדי שהמרות יעבדו בשני הצדדים, והפכו אופרטורים שחייבים לשנות את האופרנד השמאלי או קשורים אליו (+=, [], =) לאיברים.

העמסת אופרטור ה-stream

האופרטור שמעמיסים הכי הרבה הוא << להדפסה. אי אפשר להפוך אותו לאיבר של המחלקה שלכם, כי האופרנד השמאלי הוא std::ostream (כמו cout) ולא הטיפוס שלכם, ו-ostream לא שייך לכם. לכן הוא תמיד פונקציה חיצונית שמקבלת את ה-stream בהפניה שאינה const ומחזירה אותו:

#include <iostream>
using namespace std;

struct Point {
    int x, y;
};

// האופרנד השמאלי הוא ה-stream; מחזירים אותו כדי שאפשר יהיה לשרשר קריאות
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)
}

שני פרטים גורמים לזה לעבוד. ה-stream מועבר ומוחזר בהפניה (ostream&): אי אפשר להעתיק streams, והחזרת אותו stream היא מה שמאפשר לשרשר cout << "p = " << p << "\n". כל << מחזיר את ה-stream כדי של-<< הבא יהיה למה להיקשר. שכחו את return os; והשרשור נשבר.

אופרטורי השוואה

כדי להשוות את האובייקטים שלכם עם ==, < וחבריהם, מעמיסים את אופרטורי ההשוואה. לפני C++20 כתבתם כל אחד ידנית, והמלכודת העיקרית היא ש-operator< חייב להחזיר bool ולהגדיר סדר עקבי:

#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;        // הכרעת שוויון לפי minor
}

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

כתיבה ידנית של כל שש ההשוואות (==, !=, <, <=, >, >=) מייגעת ומועדת לטעויות. C++20 הוסיפה את אופרטור ההשוואה התלת-כיוונית <=> (ה"חללית"). הגדרתו כ-default יחד עם == מייצרת בשבילכם את כל ההשוואות:

#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 אומר לקומפיילר להשוות איברים לפי סדר ההצהרה, וזה בדיוק הסדר הלקסיקוגרפי שהייתם כותבים ידנית. העדיפו את זה בקומפיילרים מודרניים.

אופרטור ההשמה והמלכודות שלו

operator= (השמת העתקה) הוא מיוחד: הקומפיילר מייצר אחד בשבילכם, ולמחלקות פשוטות ברירת המחדל הזו נכונה. צריך לכתוב אחד משלכם רק כשהמחלקה מנהלת משאב, כמו זיכרון גולמי או ידית קובץ, שבו העתקה איבר אחר איבר תהיה שגויה. החתימה הקנונית מחזירה *this בהפניה כדי שהשמות יוכלו להשתרשר (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;   // הגנה מפני השמה עצמית
        delete[] data;                      // משחררים את מה שהחזקנו
        size = other.size;
        data = new int[size];               // מקצים מחדש
        for (int i = 0; i < size; ++i) data[i] = other.data[i];
        return *this;                       // מאפשר a = b = c
    }
    int length() const { return size; }
};

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

שתי מלכודות חיות בפונקציה הקצרה הזו. הראשונה היא בדיקת ההשמה העצמית if (this == &other): בלעדיה, a = a היה מבצע delete[] data ואז קורא מה-other.data ששוחרר זה עתה: התנהגות לא מוגדרת. השנייה היא שהסדר חשוב: בגרסה שכותבים ידנית אסור למחוק את החוצץ הישן לפני שהעתקתם בבטחה את החדש (מימוש אמיתי לרוב מקצה קודם, או משתמש ב-idiom של copy-and-swap, כך שהקצאה שנכשלה משאירה את האובייקט שלם).

מלכודת רחבה יותר: אל תעמיסו אופרטורים בדרכים מפתיעות. operator+ שמשנה בסתר את האופרנד השמאלי שלו, או operator== שאינו סימטרי, יבלבלו כל קורא וישברו קוד של הספרייה הסטנדרטית שמניח את המשמעויות הרגילות. העמיסו אופרטורים רק כשהפעולה באמת "דומה לחיבור" או "דומה לשוויון" עבור הטיפוס שלכם.

הבא בתור: מצייני גישה

שימו לב שכל דוגמה שמרה את משתני האיברים שלה private וחשפה התנהגות דרך ממשק ציבורי קטן: בנאים, אופרטורים וכמה מתודות. הגבול הזה בין מה שגלוי לעולם החיצון לבין מה שמוסתר בתוך המחלקה נשלט על ידי מצייני גישה: public, private ו-protected. בהמשך נראה בדיוק מה כל אחד מהם מתיר, למה נתונים private עם מתודות ציבוריות הם ברירת המחדל לכימוס טוב, ואיך protected משתלב בירושה.