الوراثة الافتراضية

جزء من قسم البرمجة كائنية التوجه في رحلة C++ على Coddy. الدرس 54 من 104.

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

class Animal {
public:
    int age;
};

class Mammal : public Animal {};
class Bird : public Animal {};

class Bat : public Mammal, public Bird {};

Bat b;
b.age = 5;  // خطأ: غامض - أي 'age'؟

يحتوي الصنف Bat على كائنين فرعيين منفصلين من Animal: أحدهما عبر Mammal والآخر عبر Bird. ينشئ هذا مخطط الوراثة على شكل ماسة الذي يمنح المشكلة اسمها.

الوراثة الافتراضية تحل هذه المشكلة من خلال ضمان وجود نسخة واحدة فقط من base المشترك. أضف الكلمة المفتاحية virtual عند الوراثة من base المشترك:

class Animal {
public:
    int age;
    Animal(int a = 0) : age(a) {}
};

class Mammal : virtual public Animal {
public:
    Mammal(int a = 0) : Animal(a) {}
};

class Bird : virtual public Animal {
public:
    Bird(int a = 0) : Animal(a) {}
};

class Bat : public Mammal, public Bird {
public:
    Bat(int a) : Animal(a), Mammal(a), Bird(a) {}
};

Bat b(5);
b.age = 10;  // يعمل! يوجد 'age' واحد فقط

لاحظ أن Bat يجب أن يهيّئ Animal مباشرةً في مُنشئه. مع الوراثة الافتراضية، تكون الفئة الأكثر اشتقاقًا مسؤولة عن إنشاء الفئة الأساسية الافتراضية، بغضّ النظر عن الفئات الوسيطة.

التحدي

سهل

لنَبْنِ نظامًا لإدارة الموظفين يوضّح كيف يحلّ الوراثة الافتراضية مشكلة المعيّنة. ستنشئ تسلسلاً هرميًا ترث فيه TeamLead من كلٍّ من Developer وManager، اللذين يشتركان معًا في فئة أساسية مشتركة هي Employee.

ستنظّم التعليمات البرمجية عبر أربعة ملفات:

Employee.h: Define الفئة الأساسية المشتركة Employee التي تحتوي على:
- عضوي std::string name وint id بمستوى protected
- منشئًا يأخذ القيمتين كلتيهما ويطبع: Employee [<name>] hired with ID <id>
- دالة getInfo() عامة تطبع: Employee: <name> (ID: <id>)
- مدمّرًا افتراضيًا يطبع: Employee [<name>] record closed
Developer.h: Define فئة Developer تستخدم virtual public inheritance من Employee:
- عضو std::string language بمستوى protected
- منشئًا يأخذ name وid وlanguage: يمرّر name وid إلى Employee، ويخزّن language، ويطبع: Developer [<name>] specializes in <language>
- دالة code() عامة تطبع: <name> is coding in <language>
- مدمّرًا يطبع: Developer [<name>] signed off
Manager.h: Define فئة Manager تستخدم virtual public inheritance من Employee:
- عضو int teamSize بمستوى protected
- منشئًا يأخذ name وid وحجم الفريق: يمرّر name وid إلى Employee، ويخزّن حجم الفريق، ويطبع: Manager [<name>] leads a team of <teamSize>
- دالة manage() عامة تطبع: <name> is managing <teamSize> people
- مدمّرًا يطبع: Manager [<name>] stepped down
main.cpp: اقرأ أربع مدخلات، كلٌّ منها في سطر منفصل:
1. الاسم (string)
2. معرّف Employee (integer)
3. لغة البرمجة (string)
4. حجم الفريق (integer)
عرّف فئة TeamLead ترث علنًا من كلٍّ من Developer وManager:
- منشئًا يأخذ المعاملات الأربعة جميعها، ويجب أن يهيّئ Employee (القاعدة الافتراضية) directly، ثم Developer وManager
- يجب أن يطبع المنشئ: TeamLead [<name>] ready to lead and code!
- دالة showRole() تستدعي getInfo() ثم code() ثم manage() بهذا الترتيب
- مدمّرًا يطبع: TeamLead [<name>] promoted out
أنشئ كائن TeamLead داخل نطاق block، واستدعِ showRole()، ثم دعه يخرج من النطاق. بعد block، اطبع: Organization restructured!

على سبيل المثال، مع المدخلات Alice و101 وC++ و5:

Employee [Alice] hired with ID 101
Developer [Alice] specializes in C++
Manager [Alice] leads a team of 5
TeamLead [Alice] ready to lead and code!
Employee: Alice (ID: 101)
Alice is coding in C++
Alice is managing 5 people
TeamLead [Alice] promoted out
Manager [Alice] stepped down
Developer [Alice] signed off
Employee [Alice] record closed
Organization restructured!

لاحظ أنه لا يوجد سوى استدعاء واحد لمنشئ Employee واستدعاء واحد لمدمّر Employee: تضمن virtual inheritance وجود نسخة واحدة فقط من القاعدة المشتركة. يجب على TeamLead أن يهيّئ Employee directly، لأنه مع virtual inheritance تكون الفئة الأكثر اشتقاقًا مسؤولة عن إنشاء القاعدة الافتراضية.

جرّب بنفسك

#include <iostream>
#include <string>
#include "Developer.h"
#include "Manager.h"

using namespace std;

// TODO: عرّف صنف TeamLead الذي يرث علناً من كلٍ من Developer و Manager
// تذكر: مع الوراثة الافتراضية، يجب على TeamLead تهيئة Employee مباشرة (القاعدة الافتراضية)
class TeamLead : public Developer, public Manager {
public:
    // TODO: نفّذ المُنشئ الذي يأخذ name و id و language و teamSize
    // يجب التهيئة: Employee أولاً (القاعدة الافتراضية)، ثم Developer، ثم Manager
    // Should print: TeamLead [<name>] ready to lead and code!
    TeamLead(const std::string& name, int id, const std::string& language, int teamSize)
        : Employee(name, id),
          Developer(name, id, language),
          Manager(name, id, teamSize) {
        // TODO: اطبع رسالة المُنشئ
    }

    // TODO: نفّذ الدالة showRole()
    // يجب استدعاء getInfo() و code() و manage() بهذا الترتيب
    void showRole() {
        // TODO: استدعِ الدوال الثلاث
    }

    // TODO: نفّذ المُدمّر
    // Should print: TeamLead [<name>] promoted out
    ~TeamLead() {
        // TODO: اطبع رسالة المُدمّر
    }
};

int main() {
    // اقرأ المدخلات
    string name;
    int id;
    string language;
    int teamSize;

    getline(cin, name);
    cin >> id;
    cin.ignore();
    getline(cin, language);
    cin >> teamSize;

    // TODO: أنشئ كائن TeamLead داخل نطاق كتلة
    // استدعِ showRole()، ثم اتركه يخرج من النطاق
    {
        // TODO: أنشئ TeamLead واستدعِ showRole()
    }

    // اطبع الرسالة النهائية بعد الكتلة
    cout << "Organization restructured!" << endl;

    return 0;
}