פונקציות וירטואליות ב-C++: פולימורפיזם בהסבר ברור

למה ירושה לבדה לא מספיקה

בדף הקודם בניתם היררכיית מחלקות: מחלקה נגזרת יורשת חברים ממחלקת הבסיס שלה. אבל יש מלכודת. כשקוראים למתודה דרך מצביע למחלקת בסיס, C++ מחליטה איזו פונקציה להריץ לפי הטיפוס של המצביע, לא לפי הטיפוס האמיתי של האובייקט. לכן Animal* שבפועל מצביע על Dog עדיין קורא לגרסה של Animal.

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

#include <iostream>
using namespace std;

struct Animal {
    void speak() { cout << "...\n"; }   // לא וירטואלית
};

struct Dog : Animal {
    void speak() { cout << "Woof\n"; }
};

int main() {
    Animal* a = new Dog();
    a->speak();   // מדפיס "...": הגרסה של Animal, לא Woof!
    delete a;
    return 0;
}

האובייקט הוא באמת Dog, ובכל זאת a->speak() הריץ את Animal::speak(). מכיוון ש-speak לא וירטואלית, המהדר בחר את הפונקציה בזמן קומפילציה לפי הטיפוס הסטטי Animal*. זה הבאג שפונקציות וירטואליות נועדו לתקן.

איך הופכים פונקציה לווירטואלית

מוסיפים את מילת המפתח virtual למתודה במחלקת הבסיס. עכשיו הקריאה מוכרעת בזמן ריצה לפי הטיפוס האמיתי של האובייקט: זה dynamic dispatch.

#include <iostream>
using namespace std;

struct Animal {
    virtual void speak() { cout << "...\n"; }
};

struct Dog : Animal {
    void speak() override { cout << "Woof\n"; }
};

struct Cat : Animal {
    void speak() override { cout << "Meow\n"; }
};

int main() {
    Animal* pets[] = { new Dog(), new Cat(), new Animal() };

    for (Animal* p : pets) {
        p->speak();   // כל אחד מריץ את הגרסה שלו
    }
    // Woof / Meow / ...

    for (Animal* p : pets) delete p;
    return 0;
}

לולאה אחת על Animal*, שלוש התנהגויות שונות. המצביע לבסיס "יודע" את הטיפוס האמיתי בזמן ריצה ומפנה את הקריאה בהתאם. המנגנון היחיד הזה, ממשק אחד ומימושים רבים, הוא מה ש_פולימורפיזם_ אומר ב-C++.

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

תמיד השתמשו במילת המפתח override

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

struct Animal {
    virtual void speak() const { }   // שימו לב: const
};

struct Dog : Animal {
    void speak() { }            // לא const: זו פונקציה חדשה, לא דריסה!
    void speak() override { }   // שגיאה: 'speak' לא דורסת, המהדר אומר לכם מיד
};

בלי override, ה-speak() הראשונה מתקמפלת בלי בעיה אבל אף פעם לא נקראת דרך Animal*, כי החתימה שלה שונה מזו של הבסיס (חסר const). הייתם מבזבזים אחר צהריים שלם בתהייה למה הדריסה שלכם לא עושה כלום. עם override, המהדר תופס את אי ההתאמה במקום. הוסיפו אותו לכל פונקציה דורסת.

פונקציות וירטואליות טהורות ומחלקות אבסטרקטיות

לפעמים למחלקת הבסיס אין ברירת מחדל הגיונית: איזה קול משמיע "Animal" כללי? במקרה כזה, הצהירו על הפונקציה כ_וירטואלית טהורה_ על ידי השמה של = 0. זה משאיר אותה בלי גוף והופך את המחלקה למחלקה אבסטרקטית שאי אפשר ליצור ממנה מופע בפני עצמה. היא קיימת רק כדי להגדיר ממשק שמחלקות נגזרות חייבות למלא.

#include <iostream>
using namespace std;

struct Shape {
    virtual double area() const = 0;   // וירטואלית טהורה: בלי גוף, חייבים לדרוס
    virtual ~Shape() = default;        // destructor וירטואלי (ראו בסעיף הבא)
};

struct Circle : Shape {
    double r;
    Circle(double radius) : r(radius) {}
    double area() const override { return 3.14159 * r * r; }
};

struct Rectangle : Shape {
    double w, h;
    Rectangle(double width, double height) : w(width), h(height) {}
    double area() const override { return w * h; }
};

int main() {
    // Shape s;   // שגיאה: אי אפשר ליצור מופע של מחלקה אבסטרקטית
    Shape* shapes[] = { new Circle(2.0), new Rectangle(3.0, 4.0) };

    for (Shape* s : shapes) {
        cout << "area = " << s->area() << "\n";
    }
    // area = 12.5664 / area = 12

    for (Shape* s : shapes) delete s;
    return 0;
}

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

כלל ה-destructor הווירטואלי

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

#include <iostream>
using namespace std;

struct Base {
    ~Base() { cout << "~Base\n"; }   // לא וירטואלי: באג!
};

struct Derived : Base {
    ~Derived() { cout << "~Derived\n"; }
};

int main() {
    Base* p = new Derived();
    delete p;   // מדפיס רק "~Base": ~Derived אף פעם לא רץ!
    return 0;
}

התיקון הוא מילה אחת: הפכו את ה-destructor של הבסיס ל-virtual. אז delete p מריץ קודם את ~Derived ואחר כך את ~Base, בדיוק כמו שצריך.

struct Base {
    virtual ~Base() { cout << "~Base\n"; }   // נכון
};
// עכשיו: ~Derived ואחר כך ~Base

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

טעויות ומלכודות נפוצות

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

Object slicing. אם מעבירים או שומרים אובייקט נגזר by value במשתנה מטיפוס הבסיס, החלק הנגזר "נחתך" ונשארים עם אובייקט בסיס פשוט: ה-dispatch הווירטואלי כבר לא מגיע לדריסה. תמיד השתמשו במצביעים או בהפניות לפולימורפיזם:

Dog d;
Animal a = d;   // נחתך: a הוא עכשיו רק Animal, החלק של Dog נעלם
a.speak();      // מריץ את Animal::speak למרות שהיא וירטואלית

Animal& ref = d;   // בסדר: ההפניה שומרת על הטיפוס האמיתי
ref.speak();       // מריץ את Dog::speak

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

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

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

הבא בתור: העמסת אופרטורים

פונקציות וירטואליות מאפשרות לאובייקטים שלכם להתאים את ה_התנהגות_ שלהם דרך ממשק משותף. הדף הבא מראה איך להתאים את ה_אופרטורים_ שפועלים על האובייקטים שלכם: עם operator overloading אפשר ללמד את הטיפוסים שלכם להגיב ל-+, ==, << ועוד, כך ש-Vector + Vector או cout << myObject נקראים באופן טבעי כמו בטיפוסים מובנים.