التحميل الزائد للدوال في C++: نفس الاسم، معاملات مختلفة

اسم واحد، نسخ كثيرة

كثيرًا ما تحتاج إلى نفس العملية لأنواع مختلفة من البيانات: طباعة int، وطباعة string، وطباعة double. في بعض اللغات قد تخترع printInt وprintString وprintDouble. أمّا C++ فتتيح لك إعطاءها جميعًا نفس الاسم، وتميّز بينها بمعاملاتها. هذا هو التحميل الزائد للدوال.

القاعدة بسيطة: يمكن لعدة دوال أن تتشارك اسمًا واحدًا طالما اختلفت قوائم معاملاتها؛ في عدد المعاملات أو أنواعها أو ترتيبها. ينظر المُترجِم إلى الوسائط عند كل موضع استدعاء ويختار لك النسخة المطابِقة.

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

void print(int x) {
    cout << "int: " << x << "\n";
}

void print(double x) {
    cout << "double: " << x << "\n";
}

void print(const string& x) {
    cout << "string: " << x << "\n";
}

int main() {
    print(42);          // int: 42
    print(3.14);        // double: 3.14
    print(string("hi")); // string: hi
}

ثلاث دوال، اسم واحد. يصل كل استدعاء إلى النسخة التي يلائم نوع معاملها الوسيطَ. هذا هو ما يجعل std::cout << x يعمل مع الأعداد الصحيحة والأعداد العشرية والسلاسل النصية على حدّ سواء؛ فـoperator<< محمّل زائدًا مرّاتٍ عديدة.

ما الذي يُعدّ نسخةً مختلفة

تتميّز النسخة بقائمة معاملاتها فقط. يمكنك أن تغيّر:

int  area(int side);                 // معامل واحد
int  area(int width, int height);    // معاملان  -> مختلفة
double area(double r);               // نوع مختلف -> مختلفة

void log(string msg, int level);     // الترتيب مهم...
void log(int level, string msg);     // ...لذا هذه أيضًا مختلفة

كلٌّ منها نسخة مشروعة ومستقلة. يبني المُترجِم مجموعة مرشّحين من كل الدوال المسمّاة area، ثم يطابق حسب عدد الوسائط ونوعها.

نوع القيمة المعادة وحده لا يكفي

ها هي العقبة التي يتعثّر فيها الجميع تقريبًا: لا يمكنك التحميل الزائد اعتمادًا على نوع القيمة المعادة. لا تؤدّي القيمة المعادة أيّ دور في اختيار النسخة، لأن المُترجِم يقرّر أيّ دالة يستدعي من الوسائط قبل أن ينظر إطلاقًا إلى ما يُرجَع.

int    convert(double x);   // OK
double convert(double x);   // خطأ: إعادة تعريف - نوع القيمة المعادة فقط هو ما يختلف

لن يُترجَم هذا. إذا كانت قوائم المعاملات متطابقة، فإن التصريحين هما نفس الدالة من حيث التحميل الزائد، وتحصل على خطأ إعادة تعريف. للتفريع بحسب نوع النتيجة، غيّر معاملًا (أو استخدم القوالب / تحويل النوع عبر static_cast عند موضع الاستدعاء بدلًا من ذلك).

كيف يختار حلّ التحميل الزائد فائزًا

عندما تُجري استدعاءً، يرتّب المُترجِم كل النسخ القابلة للاستخدام ويختار أفضل تطابق. على نحوٍ تقريبي، يفضّل بهذا الترتيب:

1. تطابقًا تامًّا (لا حاجة إلى تحويل).
2. ترقية (مثل char أو short -> int، وfloat -> double).
3. تحويلًا قياسيًا (مثل int -> double، وdouble -> int، ومؤشّر إلى الصنف الأساس).

إذا كانت نسخة واحدة بالضبط أفضل بصرامة من كل ما عداها، فهي الفائزة. لاحظ كيف يتغلّب التطابق التام على التحويل:

#include <iostream>
using namespace std;

void show(int x)    { cout << "int version\n"; }
void show(double x) { cout << "double version\n"; }

int main() {
    show(5);     // int version  (تطابق تام)
    show(5.0);   // double version (تطابق تام)
    show('A');   // int version  ('A' تُرقَّى من char -> int)
}

'A' هو من نوع char، لكنّ الترقية إلى int تتفوّق على التحويل إلى double، لذا يُستدعى تحميل int. قواعد الترتيب هذه هي السبب في أن حلّ التحميل الزائد عادةً "يفعل الصواب تمامًا" — ويفاجئك من حينٍ لآخر.

فخّ الغموض

إذا كانت نسختان متساويتين في الجودة — ولا واحدة أفضل بصرامة — يرفض المُترجِم التخمين ويبلّغ عن استدعاء غامض. الحالة المدرسية هي نسختان تحتاج كلٌّ منهما إلى تحويلٍ من نفس الرتبة:

void f(int x);
void f(double x);

f(0L);   // خطأ: غامض - long -> int و long -> double تحويلان من نفس الرتبة

لا int ولا double تطابق تام لـlong، وكلا التحويلين على نفس الرتبة، فيصبح الاستدعاء غامضًا. لديك حلّان نظيفان:

#include <iostream>
using namespace std;

void f(int x)    { cout << "int\n"; }
void f(double x) { cout << "double\n"; }

int main() {
    f(static_cast<int>(0L));  // أزِل الغموض بتحويل -> int
    // أو أضِف نسخة بتطابق تام مثل  void f(long)  لتفوز دون منازع
}

مفاجأة ذات صلة: تمرير سلسلة نصية حرفية. ستتنافس كلٌّ من void g(const string&) وvoid g(bool) على g("hi")، وقد تفوز bool، لأن const char* يتحوّل إلى bool (غير الصفري -> true) بخطواتٍ أقلّ من بناء std::string. إن رأيت يومًا سلسلةً حرفية تستدعي على نحوٍ غامض نسخة bool لديك، فهذا هو السبب — أضِف نسخة const char* أو const string& لتأخذ التطابق التام.

التحميل الزائد والوسائط الافتراضية لا ينسجمان جيدًا

الوسائط الافتراضية ليست بديلًا عن التحميل الزائد، والجمع بينهما يخلق غموضًا. إذ يمكن لكلٍّ منهما أن يجيب على نفس الاستدعاء، فلا يستطيع المُترجِم الاختيار:

void connect(string host, int port = 8080);   // يمكن استدعاؤها بوسيط واحد
void connect(string host);                     // يمكن استدعاؤها أيضًا بوسيط واحد

connect("localhost");   // خطأ: غامض - كلتاهما تطابق وسيطًا واحدًا

اختر نهجًا واحدًا لكل شكل استدعاء. استخدم الوسائط الافتراضية عندما يكون السلوك متطابقًا وتريد فقط معاملات اختيارية؛ واستخدم التحميل الزائد عندما يجب أن تشغّل قوائمُ الوسائط المختلفة شِفرةً مختلفة فعلًا. أمّا مزجهما بحيث يتصادم توقيعان لنفس عدد الوسائط فهو خطأ غموض مضمون.

تمييز أخير يستحق الترسيخ: التحميل الزائد ليس التجاوز (override). يُحَلّ التحميل الزائد وقت الترجمة بين دوالٍ في نفس النطاق بنفس الاسم لكن بمعاملات مختلفة. أمّا التجاوز فيستبدل دالة virtual في صنفٍ مشتقّ وقت التشغيل ويتطلّب نفس التوقيع — وهو موضوع نتناوله في الدوال الافتراضية لاحقًا.

التالي: تعابير لامبدا

يمنح التحميل الزائد اسمًا واحدًا عدة تنفيذات مُحدَّدة الأنواع تُختار وقت الترجمة. لكنّك أحيانًا لا تريد دالة مسمّاة على الإطلاق — تحتاج إلى دالة صغيرة عابرة تُعرَّف في موضع استخدامها تمامًا، غالبًا لتمريرها إلى خوارزمية مثل sort. هذا بالضبط ما هي عليه تعابير لامبدا: دوال مجهولة يمكنك كتابتها ضمن السطر، والتقاط المتغيّرات المحيطة بها، وتمريرها في تعبير واحد. سنرى تاليًا كيف نكتبها ومتى تتفوّق على دالة مسمّاة كاملة.