ירושה ב-C++: מחלקות בסיס ומחלקות נגזרות

שימוש חוזר במחלקה על ידי הרחבתה

כבר בניתם מחלקות עם בנאים וניקיתם אותן עם הורסים. ירושה היא הצעד הבא: במקום להעתיק את האיברים של מחלקה אחת לאחרת, מצהירים שמחלקה חדשה היא גרסה מיוחדת של מחלקה קיימת, ונותנים לה לרשת הכול אוטומטית.

המחלקה הקיימת היא מחלקת הבסיס (או ההורה), והחדשה היא המחלקה הנגזרת (או הילד). מחלקה נגזרת מתחילה עם כל הנתונים וההתנהגות של הבסיס, ואז מוסיפה או משנה את מה שמייחד אותה. זה הכלי העיקרי של C++ ליחס "is-a": Dog הוא Animal, ו-SavingsAccount הוא BankAccount.

תחביר בסיסי: class Derived : public Base

יורשים על ידי כתיבת נקודתיים אחרי שם המחלקה הנגזרת, ואחריהן מציין גישה ושם מחלקת הבסיס. הצורה הנפוצה ביותר היא ירושה public.

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

class Animal {
public:
    string name;
    void eat() {
        cout << name << " is eating." << endl;
    }
};

// Dog הוא Animal: הוא מקבל את name ואת eat() בחינם
class Dog : public Animal {
public:
    void bark() {
        cout << name << " says woof!" << endl;
    }
};

int main() {
    Dog d;
    d.name = "Rex";   // איבר שעבר בירושה
    d.eat();          // מתודה שעברה בירושה
    d.bark();         // מתודה של Dog עצמו
    return 0;
}

Dog אף פעם לא מצהיר על name או על eat(), ובכל זאת שניהם עובדים על אובייקט Dog, כי הם עברו בירושה מ-Animal. המחלקה הנגזרת חופשייה להוסיף איברים כמו bark() שהבסיס לא יודע עליהם דבר.

protected: איברים לילדים בלבד

איבר private של הבסיס אינו נגיש בתוך המחלקה הנגזרת: ירושה לא שוברת את הכימוס. כשרוצים שהפרטים הפנימיים של הבסיס יהיו מוסתרים מהעולם החיצון אבל זמינים לתת-מחלקות, משתמשים במציין הגישה protected.

#include <iostream>
using namespace std;

class BankAccount {
protected:
    double balance = 0;   // גלוי למחלקות נגזרות, לא לגורמים מבחוץ
public:
    void deposit(double amount) { balance += amount; }
    double getBalance() const { return balance; }
};

class SavingsAccount : public BankAccount {
public:
    void addInterest(double rate) {
        balance += balance * rate;   // תקין: איבר protected נגיש כאן
    }
};

int main() {
    SavingsAccount s;
    s.deposit(1000);
    s.addInterest(0.05);
    cout << s.getBalance() << endl; // 1050
    // s.balance = 0;   // שגיאה: protected, לא נגיש מ-main
    return 0;
}

חשבו על שלוש הרמות כעל טבעות מעגליות: private הוא "רק המחלקה הזו", protected הוא "המחלקה הזו והצאצאים שלה", ו-public הוא "כולם". ראו את access-specifiers לתמונה המלאה.

סדר הבנאים וההורסים

אובייקט נגזר מכיל תת-אובייקט של הבסיס, וחלק הבסיס הזה חייב להיות חי לפני שהחלק הנגזר נבנה. לכן הבנייה רצה מהבסיס קודם, וההריסה רצה מהנגזרת קודם (בסדר ההפוך בדיוק). אם הבסיס צריך ארגומנטים לבנאי, מעבירים אותם דרך רשימת האתחול של האיברים.

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

class Animal {
    string name;
public:
    Animal(string n) : name(n) {
        cout << "Animal ctor: " << name << endl;
    }
    ~Animal() { cout << "Animal dtor: " << name << endl; }
};

class Dog : public Animal {
public:
    // מעבירים את הארגומנט לבנאי של הבסיס
    Dog(string n) : Animal(n) {
        cout << "Dog ctor" << endl;
    }
    ~Dog() { cout << "Dog dtor" << endl; }
};

int main() {
    Dog d("Rex");
    return 0;
}

הפלט ממחיש את הסדר:

Animal ctor: Rex   // הבסיס נבנה ראשון
Dog ctor           // ואז החלק הנגזר
Dog dtor           // ההריסה בסדר הפוך...
Animal dtor: Rex   // ...הבסיס אחרון

אם שוכחים את : Animal(n) ולבסיס אין בנאי ברירת מחדל, הקוד לא יתקמפל: ל-C++ אין מושג איך לבנות את חלק הבסיס. מחלקת בסיס שמתכוונים לרשת ממנה צריכה כמעט תמיד להצהיר על הורס (ולעיתים קרובות, כפי שהעמוד הבא מראה, על הורס וירטואלי).

דריסה: הגדרה מחדש של מתודת בסיס

מחלקה נגזרת יכולה להחליף מתודה שעברה בירושה על ידי הצהרה על מתודה עם אותה חתימה. עדיין אפשר להגיע למקורית דרך Base::method().

#include <iostream>
using namespace std;

class Shape {
public:
    void describe() const { cout << "A generic shape" << endl; }
};

class Circle : public Shape {
public:
    void describe() const {
        Shape::describe();              // קוראים במפורש לגרסת הבסיס
        cout << "...specifically a circle" << endl;
    }
};

int main() {
    Circle c;
    c.describe();
    return 0;
}

זו הסתרת שמות פשוטה, לא פולימורפיזם: איזה describe() ירוץ נקבע בזמן הקימפול לפי הטיפוס הסטטי של המשתנה. זו מגבלה קריטית: אם קוראים דרך Shape& או Shape* שמצביע בפועל על Circle, עדיין תקבלו את Shape::describe(). כדי לתקן את זה צריך virtual, וזה הנושא של העמוד הבא.

היזהרו מ-object slicing

מכיוון שהפניה או מצביע מטיפוס הבסיס יכולים להתייחס לאובייקט נגזר, מפתה להעתיק אובייקט נגזר למשתנה מטיפוס הבסיס. אל תעשו את זה: החלק הנגזר נחתך.

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

class Animal {
public:
    string name = "?";
};

class Dog : public Animal {
public:
    string breed = "Labrador";
};

int main() {
    Dog d;
    d.name = "Rex";

    Animal a = d;   // SLICING: רק החלק של Animal מועתק
    cout << a.name << endl;   // Rex
    // a.breed נעלם: הוא אף פעם לא היה חלק מ-Animal
    return 0;
}

a הוא Animal אמיתי, לא Dog עם תווית של בסיס, ולכן breed פשוט לא קיים בו. כדי לעבוד עם אובייקטים נגזרים באופן פולימורפי חייבים להשתמש בהפניה (Animal&) או במצביע (Animal*) מטיפוס הבסיס, ואף פעם לא בערך מטיפוס הבסיס. ה-slicing שקט: הקוד מתקמפל בלי בעיה ופשוט משמיט נתונים בשקט, ולכן זה אחד מבאגי הירושה שהכי קל לשחרר לייצור.

טעויות נפוצות שכדאי להימנע מהן

• לצפות שאיברי private של הבסיס יהיו נגישים בילד. הם לא. השתמשו ב-protected לנתונים שהמחלקה הנגזרת באמת צריכה, והשאירו מצב פנימי באמת כ-private.
• לשכוח להעביר ארגומנטים לבנאי הבסיס. אם לבסיס אין בנאי ברירת מחדל, חייבים לקרוא לו במפורש ברשימת האתחול של הבנאי הנגזר (: Base(args)).
• לחתוך אובייקט נגזר לערך מטיפוס הבסיס. העתקה של Dog ל-Animal משמיטה את כל מה שייחודי ל-Dog. העבירו ושמרו במקום זאת הפניות או מצביעים לבסיס.
• שימוש מופרז בירושה לשם שימוש חוזר בקוד. ירושה ממדלת "is-a". אם היחס הוא בעצם "has-a" (ל-Car יש Engine), העדיפו הרכבה (composition), כלומר אובייקט איבר, על פני ירושה.

הבא בתור: פונקציות וירטואליות

הדריסה שראיתם נפתרה בזמן הקימפול, ולכן קריאה דרך מצביע לבסיס התעלמה מהגרסה הנגזרת. העמוד הבא, virtual-functions, מציג את מילת המפתח virtual ואת override: המנגנון שגורם לטיפוס בזמן הריצה להחליט איזו מתודה תרוץ, מאפשר פולימורפיזם אמיתי ומסביר למה מחלקות בסיס צריכות הורסים וירטואליים.