الـ Mixins عبر CRTP

جزء من قسم Object Oriented Programming في رحلة C++ على Coddy — الدرس 77 من 104.

يُعد نمط القالب المتكرر بشكل غريب (Curiously Recurring Template Pattern - CRTP) تقنية ترث فيها الفئة (class) من فئة أساسية قالبية (template base class)، مع تمرير نفسها كمعامل للقالب (template argument). يتيح ذلك تعدد الأشكال في وقت التجميع (compile-time polymorphism) ويسمح للفئات الأساسية بالوصول إلى أعضاء الفئة المشتقة دون الحاجة إلى دوال افتراضية (virtual functions).

يبدو هيكل CRTP الأساسي كما يلي:

template <typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class MyClass : public Base<MyClass> {
public:
    void implementation() {
        std::cout << "MyClass implementation\n";
    }
};

يعتبر نمط CRTP قويًا بشكل خاص لإنشاء الـ mixins - وهي وظائف قابلة لإعادة الاستخدام يمكن "دمجها" في الأصناف (classes). وعلى عكس الوراثة التقليدية، تضيف الـ mixins قدرات دون إنشاء تسلسلات هرمية عميقة:

template <typename Derived>
class Printable {
public:
    void print() const {
        const Derived& self = static_cast<const Derived&>(*this);
        std::cout << self.toString() << "\n";
    }
};

class Person : public Printable<Person> {
    std::string name;
public:
    Person(const std::string& n) : name(n) {}
    std::string toString() const { return "Person: " + name; }
};

// الاستخدام:
Person p("Alice");
p.print();  // المخرجات: Person: Alice

الميزة الأساسية هي أن جميع استدعاءات الدوال (method calls) يتم حلها في وقت التجميع (compile time)، مما يلغي العبء الإضافي للدوال الافتراضية (virtual function overhead). يمكنك دمج عدة mixins من نوع CRTP لتكوين الوظائف، مما يجعلها بديلاً مرناً لتعدد الأشكال في وقت التشغيل (runtime polymorphism) عندما تكون الأنواع معروفة في وقت التجميع (compile time).

التحدي

سهل

لنقم ببناء نظام تسجيل (logging) يستخدم قوالب CRTP (Curiously Recurring Template Pattern) لإضافة وظائف قابلة لإعادة الاستخدام إلى فئات مختلفة دون عبء الدوال الافتراضية (virtual functions). ستقوم بإنشاء قالبين (mixins) يمكن "دمجهما" في أي فئة: أحدهما لعدّ النسخ (instances) والآخر لإنشاء تمثيلات نصية.

ستقوم بتنظيم الكود الخاص بك عبر ثلاثة ملفات:

Mixins.h: قم بتعريف قالبي CRTP mixin يوفران وظائف قابلة لإعادة الاستخدام.
أنشئ قالب Countable الذي يتتبع عدد النسخ الموجودة من الفئة المشتقة. يجب أن يحتوي على عداد ثابت (static counter) يزداد في المشيد (constructor) وينقص في المدمر (destructor). وفر دالة ثابتة getCount() تعيد العدد الحالي.

أنشئ قالب Describable الذي يوفر دالة describe(). يجب أن تستخدم هذه الدالة static_cast للوصول إلى الفئة المشتقة واستدعاء دالة getDescription() الخاصة بها، ثم طباعة النتيجة متبوعة بسطر جديد.

تذكر أن قوالب CRTP تستخدم static_cast<Derived*>(this) للوصول إلى أعضاء الفئة المشتقة في وقت التجميع (compile time).
Entities.h: قم بتعريف فئتين للكيانات (entities) ترثان من كلا القالبين.
أنشئ فئة Player ترث من كل من Countable<Player> و Describable<Player>. يجب أن تخزن الاسم والمستوى، وتوفر دالة getDescription() تعيد سلسلة نصية بالتنسيق التالي: Player: [name] (Level [level])

أنشئ فئة Enemy ترث أيضاً من كلا القالبين. يجب أن تخزن النوع والصحة، وتوفر دالة getDescription() تعيد: Enemy: [type] with [health] HP

لا تنسَ تهيئة العداد الثابت (static counter) لكل فئة.
main.cpp: اقرأ أربعة مدخلات (كل منها في سطر منفصل):
1. اسم اللاعب (string)
2. مستوى اللاعب (integer)
3. نوع العدو (string)
4. صحة العدو (integer)
أنشئ كائناً من نوع Player وآخر من نوع Enemy بالقيم المعطاة. ثم استعرض عمل القوالب (mixins):
1. اطبع Player count: [count] باستخدام دالة getCount() الثابتة
2. اطبع Enemy count: [count]
3. استدعِ describe() على اللاعب
4. استدعِ describe() على العدو
5. أنشئ لاعباً ثانياً باسم "Guest" ومستوى 1
6. اطبع Player count: [count] مرة أخرى لإظهار العدد المحدث
7. استدعِ describe() على اللاعب الثاني

على سبيل المثال، مع المدخلات Hero، 10، Dragon، و 500:

Player count: 1
Enemy count: 1
Player: Hero (Level 10)
Enemy: Dragon with 500 HP
Player count: 2
Player: Guest (Level 1)

يوضح هذا التحدي كيف تضيف قوالب CRTP وظائف (العد والوصف) إلى فئات غير مرتبطة دون استخدام الدوال الافتراضية. تكتسب كل من Player و Enemy نفس القدرات من خلال الوراثة من نفس قوالب الـ mixin، ولكن كل منهما يحتفظ بعداد نسخ منفصل خاص به لأن القالب يتم إنشاؤه (instantiated) بأنواع مختلفة.

ورقة مرجعية

يتيح **نمط القالب المتكرر بشكل غريب (CRTP)** تعدد الأشكال في وقت التجميع (compile-time polymorphism) من خلال جعل الفئة ترث من فئة أساسية قالبية، مع تمرير نفسها كوسيط للقالب:

template <typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class MyClass : public Base<MyClass> {
public:
    void implementation() {
        std::cout << "MyClass implementation\n";
    }
};

توفر **إضافات CRTP (Mixins)** وظائف قابلة لإعادة الاستخدام دون الحاجة إلى تسلسلات هرمية عميقة للوراثة:

template <typename Derived>
class Printable {
public:
    void print() const {
        const Derived& self = static_cast<const Derived&>(*this);
        std::cout << self.toString() << "\n";
    }
};

class Person : public Printable<Person> {
    std::string name;
public:
    Person(const std::string& n) : name(n) {}
    std::string toString() const { return "Person: " + name; }
};

المزايا الرئيسية:

يتم حل جميع استدعاءات الدوال في وقت التجميع
لا يوجد عبء إضافي للدوال الافتراضية (virtual functions)
يمكن دمج عدة إضافات (mixins) لتكوين الوظائف
يحافظ كل استنساخ للقالب على حالة منفصلة (على سبيل المثال، عدادات ثابتة منفصلة لكل نوع مشتق)

جرّب بنفسك

#include <iostream>
#include <string>
#include "Entities.h"

using namespace std;

int main() {
    // قراءة المدخلات
    string playerName;
    int playerLevel;
    string enemyType;
    int enemyHealth;
    
    cin >> playerName;
    cin >> playerLevel;
    cin >> enemyType;
    cin >> enemyHealth;
    
    // TODO: إنشاء Player بالاسم والمستوى المعطيين
    
    // TODO: إنشاء Enemy بالنوع والصحة المعطيين
    
    // TODO: طباعة "Player count: [count]" باستخدام Player::getCount()
    
    // TODO: طباعة "Enemy count: [count]" باستخدام Enemy::getCount()
    
    // TODO: استدعاء describe() على player
    
    // TODO: استدعاء describe() على enemy
    
    // TODO: إنشاء Player ثانٍ بالاسم "Guest" والمستوى 1
    
    // TODO: طباعة "Player count: [count]" مرة أخرى
    
    // TODO: استدعاء describe() على Player الثاني
    
    return 0;
}