في لغة C++، يشير التحميل الزائد للمشغل إلى القدرة على إعادة تعريف سلوك العوامل مثل العوامل الحسابية والمنطقية للأنواع المحددة من قبل المستخدم. العوامل الأحادية هي تلك العوامل التي تعمل على معامل واحد. يسمح لك التحميل الزائد للعوامل الأحادية بتخصيص سلوكها عند تطبيقها على كائنات من فئاتك الخاصة.

الغرض من التحميل الزائد للمعامل:

1. توفير بناء الجملة الطبيعي: يتيح لك التحميل الزائد للمعامل استخدام عوامل التشغيل مع الأنواع المعرفة من قبل المستخدم بطريقة تحاكي استخدامها مع الأنواع المضمنة. على سبيل المثال، يمكنك إضافة كائنين من فئة باستخدام عامل التشغيل +، أو ربط السلاسل باستخدام عامل التشغيل +، أو زيادة كائن باستخدام عامل التشغيل ++.
2. تحسين إمكانية القراءة: من خلال التحميل الزائد على المعاملات، يمكنك جعل التعليمات البرمجية الخاصة بك أكثر سهولة وقابلية للقراءة، حيث تتيح لك التعبير عن العمليات بطريقة طبيعية وموجزة.

مثال 1:

يوضح برنامج C++ هذا التحميل الزائد لمعامل unary ++ لفئة تسمى Unary. دعونا نحلل الكود:

#include <iostream>
using namespace std;

class Unary {
    int x, y;
public:
    Unary(int i = 0, int j = 0) {
        x = i;  
        y = j;
    }
    
    void show() {
        cout << x << " " << y << endl;
    }

    // Overloading the unary ++ operator as a member function
    void operator++() {
        x++;
        y++;
    }
};

int main() {
    Unary v(10, 20);
    v++; // Incrementing the object 'v' using overloaded ++ operator
    v.show(); // Displaying the updated values of 'x' and 'y'

    return 0;
}

شرح:

• تحتوي الفئة Unary على متغيرين خاصين للعضو x وy، ومُنشئ لتهيئتهما. بالإضافة إلى ذلك، يحتوي على دالة عضو show() لعرض قيم x وy.
• داخل تعريف الفئة، يتم تحميل المعامل الأحادي ++ بشكل زائد باستخدام دالة operator++(). تعمل هذه الدالة على زيادة قيم x وy.
• في الدالة main()، يتم إنشاء كائن v من الفئة Unary بقيم أولية 10 لـ x و20 لـ y.
• يتم تطبيق operator ++ على الكائن v باستخدام v++. وبما أنه عامل أحادي، فإنه لا يتطلب أي معامل.
• تعمل الدالة operator++() المحملة بشكل زائد على زيادة قيم x وy بمقدار واحد.
• بعد عملية الزيادة، يتم استدعاء الدالة show() لعرض القيم المحدثة لـ x وy.

ستكون مخرجات البرنامج كالتالي:

11 21

وذلك لأن قيم x وy تتزايد بمقدار 1 بعد تطبيق operator ++ على الكائن v. وبالتالي، يتم عرض القيم المحدثة كـ 11 لـ x و21 لـ y.

مثال 2:

#include <iostream>
using namespace std;
class Unary {
        int x, y;
    public:
        Unary(int i = 0, int j = 0) {
            x = i;  y = j;
        }
    void show() { cout << x << " " << y << endl; }
    Unary operator++()
    {
        x++;
        y++;
        return *this;
    }
    Unary operator++(int)
    {
        Unary t;
        t = *this;
        x++;
        y++;
        return t;
    }
};
int main()
{
    Unary v(10, 20), k;
    v++;
    k = v++;
    k.show();
    v.show();

    return 0;
}

يوضح برنامج C++ هذا التحميل الزائد للعامل unary ++ لفئة تسمى Unary، بالإضافة إلى عامل زيادة postfix ++ الذي يأخذ معلمة عدد صحيح وهمي إضافية. دعونا نحلل الكود:

• تحتوي الفئة Unary على متغيرين خاصين للعضو x وy، ومُنشئ لتهيئتهما. بالإضافة إلى ذلك، يحتوي على دالة عضو show() لعرض قيم x وy.
• داخل تعريف الفئة، يتم تحميل عامل التشغيل الأحادي ++ مرتين:
  1. تقوم دالة operator++() بتحميل عامل التشغيل البادئة ++ بشكل زائد. فهو يزيد قيم x وy ويعيد الكائن المحدث.
  2. تقوم دالة عامل التشغيل ++(int) بتحميل عامل تشغيل postfix ++ بشكل زائد بمعلمة عدد صحيح وهمي إضافية. يقوم بإنشاء كائن مؤقت t وتعيين قيم الكائن الحالي له. ثم يقوم بزيادة قيم x و y للكائن الحالي وإرجاع الكائن المؤقت t.
• في الدالة main()، يتم إنشاء كائنين v وk من الفئة Unary، مع تهيئة v بالقيم 10 لـ x و20 لـ y.
• يتم تطبيق v++ على الزيادة v باستخدام عامل زيادة postfix. سيؤدي هذا إلى زيادة قيم x وy لـ v وإرجاع كائن مؤقت بالقيم الأصلية.
• k = v++ سيقوم أولاً بتعيين الكائن المؤقت (بالقيم الأصلية) إلى k ثم يزيد v باستخدام عامل زيادة postfix.
• يتم استدعاء الدالة show() لعرض قيم k وv بعد عمليات الزيادة.

ستكون مخرجات البرنامج كالتالي:

11 21
12 22

مثال 3:

#include <iostream>
using namespace std;

class Unary {
    int x, y;
public:
    Unary(int i = 0, int j = 0) {
        x = i;  
        y = j;
    }
    
    void show() {
        cout << x << " " << y << endl;
    }

    // Overloading the prefix ++ operator
    Unary operator++() {
        x++;
        y++;
        return *this;
    }

    // Overloading the postfix ++ operator with an additional dummy integer parameter
    Unary operator++(int) {
        Unary t;
        t = *this;
        x++;
        y++;
        return t;
    }

    // Overloading the unary - operator
    Unary operator-() {
        x = -x;
        y = -y;
        return *this;
    }
};

int main() {
    Unary k(1, 2); // Create an object of the class Unary with initial values 1 and 2
    -k; // Applying unary - operator to object k
    k.show(); // Display the updated values of k

    return 0;
}

• تعمل دالة operator-() على زيادة التحميل على عامل التشغيل الأحادي. فهو يلغي قيم x وy بضربهما في -1 ويعيد الكائن المحدث.
• في الدالة main()، يتم إنشاء كائن k من الفئة Unary بالقيم الأولية 1 لـ x و2 لـ y.
• يتم تطبيق العامل الأحادي – على الكائن k باستخدام -k. سيؤدي هذا إلى إلغاء قيم x و y لـ k.
• أخيرًا، يتم استدعاء الدالة show() لعرض القيم المحدثة لـ x وy.

يشير هذا إلى أن قيم x وy للكائن k قد تم إبطالها من خلال تطبيق العامل الأحادي. وبالتالي، تصبح x -1 وy تصبح -2.

مثال 4:

#include <iostream>
using namespace std;
class Unary {
        int x, y;
    public:
        Unary(int i = 0, int j = 0) {
            x = i;  y = j;
        }
    void show() { cout << x << " " << y << endl; }
    Unary operator++()
    {
        x++;
        y++;
        return *this;
    }
    Unary operator++(int)
    {
        Unary t;
        t = *this;
        x++;
        y++;
        return t;
    }
    Unary operator-()
    {
        x = -x;
        y = -y;
        return *this;
    }
    bool operator!()
    {
        return (x == 0 && y == 0);
    }
};
int main()
{
    Unary x(1, 1);
    if (!x)
        cout << "true";
    else
        cout << "false";

    return 0;
}

• تقوم الدالة operator!() بتحميل عامل النفي المنطقي بشكل زائد!. تُرجع القيمة true إذا كان كل من x وy يساوي 0، مما يشير إلى أن الكائن منطقيًا false. وإلا فإنها ترجع false.
• في الدالة main()، يتم إنشاء كائن x من الفئة Unary بالقيم الأولية 1 لـ x و1 لـ y.
• عامل النفي المنطقي operator ! يتم تطبيقه على الكائن x باستخدام !x. إذا كانت x خاطئة منطقيًا (أي أن كلاً من x وy يساوي 0)، فسيتم طباعة "true". وإلا فإنه يطبع "false".

ستكون مخرجات البرنامج كالتالي:

false

مثال 5:

#include <iostream>
using namespace std;
class Unary {
        int x, y;
    public:
        Unary(int i = 0, int j = 0) {
            x = i;  y = j;
        }
    void show() { cout << x << " " << y << endl; }
    Unary operator++()
    {
        x++;
        y++;
        return *this;
    }
    Unary operator++(int)
    {
        Unary t;
        t = *this;
        x++;
        y++;
        return t;
    }
    Unary operator-()
    {
        x = -x;
        y = -y;
        return *this;
    }
    bool operator!()
    {
        return (x == 0 && y == 0);
    }
    Unary operator+=(Unary b2)
    {
        x += b2.x;
        y += b2.y;
        return *this;
    }
};
int main()
{
    Unary b(1, 2), b2(3, 3);
    b += b2;
    b.show();
    
    return 0;
}

تقوم الدالة operator+=() بتحميل عامل التعيين المركب += بشكل زائد. يقوم بإضافة متغيرات الأعضاء المقابلة للكائن الحالي (this) مع متغيرات الأعضاء للكائن الذي تم تمريره (b2) وإرجاع الكائن المحدث.

ستكون مخرجات البرنامج كالتالي:

4 5