تحميل المعاملات الزائد في 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
}

قاعدة عملية: اجعل المعاملات الثنائية المتماثلة (+ و == و *) غير أعضاء كي تعمل التحويلات على الجهتين؛ واجعل المعاملات التي يجب أن تعدّل المعامل التشغيلي الأول أو المرتبطة به (+= و [] و =) أعضاء.

تحميل معامل التدفق الزائد

المعامل الأكثر شيوعًا للتحميل الزائد بفارق كبير هو << للطباعة. لا يمكنك جعله عضوًا في صنفك، لأن المعامل التشغيلي الأول هو std::ostream (مثل cout)، وليس نوعك - وأنت لا تملك ostream. لذا فهو دائمًا غير عضو يأخذ التدفق بمرجع غير ثابت ويُرجعه:

#include <iostream>
using namespace std;

struct Point {
    int x, y;
};

// المعامل التشغيلي الأول هو التدفق؛ أرجعه كي يمكن تسلسل الاستدعاءات
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)
}

تفصيلان يجعلان هذا يعمل. يُمرَّر التدفق ويُرجَع بالمرجع (ostream&) - فالتدفقات لا يمكن نسخها، وإرجاع التدفق نفسه هو ما يتيح لك تسلسل cout << "p = " << p << "\n". كل << يُرجع التدفق كي يجد << التالي شيئًا يرتبط به. انسَ 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 معامل المقارنة الثلاثية <=> (معامل «المركبة الفضائية»). جعله افتراضيًا مع == يولّد لك كل المقارنات:

#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 الذي حُرِّر للتو - سلوك غير معرّف. الثاني هو أن الترتيب مهم - في النسخة المكتوبة يدويًا يجب ألا تحذف المخزن المؤقت القديم قبل أن تنسخ الجديد بأمان (غالبًا ما يخصّص التطبيق الحقيقي الذاكرة أولًا، أو يستخدم نمط copy-and-swap، بحيث يترك التخصيص الفاشل الكائن سليمًا).

مأزق أعم: لا تحمّل المعاملات بطرق مفاجئة. فـ operator+ الذي يعدّل سرًا معامله التشغيلي الأول، أو operator== الذي ليس متماثلًا، سيربك كل قارئ ويكسر شيفرة المكتبة القياسية التي تفترض المعاني المعتادة. حمّل المعاملات فقط عندما تكون العملية فعلًا «شبيهة بالجمع» أو «شبيهة بالمساواة» لنوعك.

التالي: محدّدات الوصول

لاحظ كيف أبقى كل مثال أعضاء بياناته private وأظهر السلوك عبر سطح عام صغير - بانيات ومعاملات وبضع دوال. هذا الحد بين ما هو مرئي للعالم الخارجي وما هو مخفي داخل الصنف تتحكم فيه محدّدات الوصول: public و private و protected. سننظر بعد ذلك في ما يسمح به كل منها بالضبط، ولماذا تكون البيانات private مع دوال عامة هي الخيار الافتراضي للتغليف الجيد، وكيف يتلاءم protected مع الوراثة.