قوالب C++‎: شرح الدوال والأصناف العامة

اكتبه مرة واحدة، واستخدمه مع كل نوع

في الصفحة السابقة رتّبت vector<int> باستخدام std::sort. لكن std::sort يرتّب أيضاً vector<string> وvector<double> ومصفوفة من بُناك الخاصة - من دون أن يكتب أحد دالة sort منفصلة لكل منها. هذا ليس سحراً وليس تحميلاً زائداً (overloading). إنه قالب: قطعة كود واحدة يُعيد المُصرّف استخدامها لأي نوع تسلّمه إياه.

من دون القوالب، ستكون عالقاً في نسخ المنطق نفسه ولصقه لكل نوع. إليك الدالة maximum نفسها مكتوبة ثلاث مرات، وهذا بالضبط التكرار الذي وُجدت القوالب لتقضي عليه:

int    maximum(int a, int b)       { return a > b ? a : b; }
double maximum(double a, double b) { return a > b ? a : b; }
string maximum(string a, string b) { return a > b ? a : b; }

الأجسام متطابقة. الأنواع فقط هي التي تختلف. يتيح لك القالب أن تقول "هذا يعمل مع أي نوع T" وأن تكتبه مرة واحدة.

قوالب الدوال

تحوّل دالة إلى قالب بإضافة template <typename T> أمامها واستخدام T في كل موضع يأتي فيه عادةً نوع محدد.

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

template <typename T>
T maximum(T a, T b) {
    return a > b ? a : b;
}

int main() {
    cout << maximum(3, 7) << "\n";          // 7   (T = int)
    cout << maximum(2.5, 1.1) << "\n";      // 2.5 (T = double)
    cout << maximum(string("apple"),
                    string("banana")) << "\n"; // banana (T = string)
    return 0;
}

لاحظ أنك لم تكتب أبداً maximum<int> ولا maximum<double>. ينظر المُصرّف إلى الوسائط ويستنتج ما الذي ينبغي أن يكون عليه T - هذا هو استنتاج وسائط القالب. كل نوع مختلف تستدعيها به يدفع المُصرّف إلى تنصيب (توليد) دالة محددة منفصلة خلف الكواليس.

يمكنك ذكر النوع صراحةً عندما يعجز الاستنتاج، باستخدام الأقواس الزاوية:

#include <iostream>
using namespace std;

template <typename T>
T zero() {            // لا شيء يُستنتج منه - بلا وسائط
    return T{};
}

int main() {
    cout << zero<int>() << "\n";     // 0
    cout << zero<double>() << "\n";  // 0
    return 0;
}

يكمن في الاستنتاج فخ شائع. بما أن T يجب أن يكون نوعاً واحداً، فإن خلط أنواع الوسائط يُفسده:

maximum(3, 7.5);   // خطأ: هل T من النوع int أم double؟ يرفض المُصرّف التخمين.

يمكنك إصلاح ذلك بالتصريح - maximum<double>(3, 7.5) - أو بإعطاء كل معامل معامل نوعٍ خاصاً به، وهو ما سنفعله تالياً.

معاملات الأنواع المتعددة

القالب ليس محصوراً بنوع واحد. اذكر منها ما تحتاجه، مفصولة بفواصل. هكذا تكتب دالة يمكن أن تكون معاملاتها من أنواع مختلفة:

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

template <typename A, typename B>
void printPair(A first, B second) {
    cout << first << " -> " << second << "\n";
}

int main() {
    printPair(1, "one");        // A = int, B = const char*
    printPair(3.14, true);      // A = double, B = bool
    printPair("pi", 3.14159);   // A = const char*, B = double
    return 0;
}

عندما يعتمد نوع القيمة المُعادة على المعاملات، دع المُصرّف يحلّه باستخدام auto (في C++14 وما بعده)، الذي يتناغم بطبيعته مع القوالب:

#include <iostream>
using namespace std;

template <typename A, typename B>
auto add(A a, B b) {
    return a + b;   // نوع القيمة المُعادة مُستنتَج من a + b
}

int main() {
    cout << add(2, 3) << "\n";     // 5    (int + int)
    cout << add(2, 3.5) << "\n";   // 5.5  (int + double -> double)
    return 0;
}

قوالب الأصناف

القوالب ليست للدوال فحسب - يمكن جعل الأصناف كاملةً قوالب. هكذا تعمل الحاويات القياسية تماماً: فـ vector<int> وmap<string, int> وpair<A, B> كلها قوالب أصناف. تكتب بنية البيانات مرة واحدة فتخزّن أي نوع تُمرّره كمعامل.

إليك Box عاماً صغيراً يحمل قيمة واحدة من أي نوع:

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

template <typename T>
class Box {
    T value;
public:
    Box(T v) : value(v) {}
    T get() const { return value; }
    void set(T v) { value = v; }
};

int main() {
    Box<int> intBox(42);
    Box<string> wordBox("hello");

    cout << intBox.get() << "\n";   // 42
    cout << wordBox.get() << "\n";  // hello

    intBox.set(100);
    cout << intBox.get() << "\n";   // 100
    return 0;
}

الفرق الجوهري عن قوالب الدوال: مع قالب الصنف يتعين عليك عادةً تزويد النوع بين أقواس زاوية - Box<int> - لأنه في المعايير الأقدم لا توجد وسائط بانٍ يُستنتج منها النوع. (أضاف C++17 استنتاج وسائط قالب الصنف، فصار Box b(42); يعمل أيضاً، لكن التصريح آمن دائماً ويُقرأ بوضوح.)

ستكون الأخطاء هائلة - إليك السبب

هذا هو الجزء الذي يتعثر فيه الجميع، لذا يستحق أن يُقال بصراحة. لا يُفحص القالب فحصاً كاملاً إلا عند تنصيبه بنوع حقيقي. يمكنك كتابة قالب يستخدم <، ويُصرَّف بسلاسة بمفرده - ولا يظهر الخطأ إلا في اللحظة التي تُنصّبه فيها بنوع لا يملك <.

template <typename T>
T maximum(T a, T b) {
    return a > b ? a : b;   // يتطلب أن يدعم T العامل >
}

struct Point { int x, y; };

// maximum(Point{1,2}, Point{3,4});
// خطأ: لا يوجد operator > للنوع Point. تذكر الرسالة Point وتقتبس
// كذلك هذه الدالة بأكملها، ممتدةً غالباً عبر أسطر كثيرة.

لأن المُصرّف يُحلّ النوع الكامل داخل القالب ويُبلّغ عن الإخفاقات من داخل الكود المُولَّد، يمكن لخطأ واحد أن يُنتج جداراً من المُخرجات يذكر تفاصيل المكتبة الداخلية. نصيحتان للنجاة:

• اقرأ الخطأ الأول، لا الأخير. فالأخطاء اللاحقة عادةً نتيجة تبعية للأول.
• تفحّص الرسالة بحثاً عن اسم النوع الخاص بك (هنا Point). فهذا يخبرك أي تنصيب أخفق.

الحل الحقيقي هو التأكد من أن نوعك يدعم كل ما يحتاجه القالب - وبالنسبة إلى maximum، يعني ذلك منح Point العامل operator>، وهو موضوع صفحة لاحقة. يمكن لـ المفاهيم (concepts) في C++20 الحديث أن تُقدّم هذه الأخطاء إلى مرحلة أبكر وتجعلها مقروءة، لكن نموذج الإحلال الكامن تحتها هو نفسه.

التالي: الأصناف

لقد بنيت للتوّ قالب الصنف Box - صنفاً ببيانات خاصة، وبانٍ، ودوال عضو - بينما كان تركيزك على القوالب. تتمهّل الصفحة التالية وتُعلّم الأصناف كما يجب: كيف تجمع البيانات مع الدوال التي تعمل عليها، وما الذي يتحكم فيه public وprivate فعلاً، وكيف تصل دوال العضو إلى حالة الكائن نفسه. تتضافر القوالب والأصناف باستمرار في C++ الواقعية، لذا فإن الإلمام المتين بالأصناف يجعل كتابة الكود العام أسهل بكثير.