# ירושה, פולימורפיזם ופונקציות וירטואליות **סדנה בתכנות C ו-C++ (67315) — הרצאה 11** — HUJI --- ## מהי ירושה? ירושה יוצרת מחלקות חדשות על ידי רכישת התכונות וההתנהגויות של מחלקות קיימות, ואז הרחבה או התמחות שלהן. **מחלקה נגזרת** (derived) יורשת מ**מחלקת בסיס** (base). ```cpp #include "Person.h" class Programmer : public Person { std::string _company; public: Programmer(std::string name = "", int id = 0, std::string company = ""); void change_company(std::string company); std::string get_company() const; void output_details(std::ostream& os = std::cout) const; }; ``` ```cpp Programmer::Programmer(std::string name, int id, std::string company) : Person(name, id), _company(company) { // empty -- considered elegant } ``` המחלקה הנגזרת יכולה להשתמש בכל החברים ה-public וה-protected של מחלקת הבסיס: ```cpp Programmer p("Yoram", 123, "Microsoft"); std::cout << p.get_name() << std::endl; // inherited from Person std::cout << p.get_company() << std::endl; // defined in Programmer ``` --- ## מגדירי גישה: `public`, `protected`, `private` ### גישה לחברים | מגדיר | המחלקה עצמה | מחלקות נגזרות | קוד חיצוני | |--------|-------------|----------------|------------| | `public` | כן | כן | כן | | `protected` | כן | כן | לא | | `private` | כן | לא | לא | ### גישת ירושה ```cpp class PublicDerived : public Base { }; // default for struct class ProtectedDerived : protected Base { }; class PrivateDerived : private Base { }; // default for class ``` | ירושה | `public` של הבסיס הופך ל- | `protected` של הבסיס הופך ל- | |--------|--------------------------|------------------------------| | `public` | `public` | `protected` | | `protected` | `protected` | `protected` | | `private` | `private` | `private` | !!! info "כלל אצבע" השתמשו בירושת `public` ליחסי "הוא-סוג-של" (is-a) -- מתכנת הוא אדם. השתמשו בירושת `private` ליחסי "מיושם-על-בסיס" (implemented-in-terms-of). --- ## סדר בנייה והרס **בנאים** רצים מלמעלה למטה (בסיס קודם, אחר כך נגזרת): 1. בנאי מחלקת הבסיס 2. אובייקטי חברים נבנים 3. גוף בנאי המחלקה הנגזרת **מפרקים** רצים מלמטה למעלה (נגזרת קודם, אחר כך בסיס). ```cpp class A { public: A() { std::cout << "A ctor\n"; } ~A() { std::cout << "A dtor\n"; } }; class B : public A { public: B() { std::cout << "B ctor\n"; } ~B() { std::cout << "B dtor\n"; } }; class C : public B { public: C() { std::cout << "C ctor\n"; } ~C() { std::cout << "C dtor\n"; } }; C obj; // Output: A ctor → B ctor → C ctor → C dtor → B dtor → A dtor ``` !!! warning "מלכודת נפוצה" סדר אתחול החברים עוקב אחר **סדר ההכרזה** במחלקה, לא אחר הסדר ברשימת האתחול. הקומפיילר עשוי להזהיר אם הסדרים שונים. --- ## דריסת מתודות (Method Overriding) מחלקה נגזרת יכולה **לדרוס** מתודה של מחלקת הבסיס על ידי הגדרת פונקציה עם אותו שם וחתימה: ```cpp void Person::output_details(std::ostream& os) const { os << "Name: " << _name << ", ID: " << _id; } void Programmer::output_details(std::ostream& os) const { Person::output_details(os); // call base version os << " [" << _company << "]"; } ``` --- ## רזולוציה סטטית מול דינמית ### הבעיה בלי `virtual`, הקומפיילר משתמש ב**רזולוציה סטטית** -- הוא קורא לפונקציה לפי **טיפוס המצביע**, לא לפי **טיפוס האובייקט**: ```cpp Person* p = new Programmer("Joe", 2, "Google"); p->output_details(std::cout); // calls Person::output_details! ``` ### הפתרון: `virtual` מילת המפתח `virtual` מאפשרת **רזולוציה דינמית** (פולימורפיזם) -- הפונקציה שנקראת תלויה בטיפוס האובייקט בפועל בזמן ריצה: ```cpp class Shape { public: virtual void draw() { std::cout << "Shape"; } virtual double area() = 0; // pure virtual virtual ~Shape() {} }; class Circle : public Shape { double _radius; public: Circle(double r) : _radius(r) {} void draw() override { std::cout << "Circle"; } double area() override { return 3.14159 * _radius * _radius; } }; class Square : public Shape { double _side; public: Square(double s) : _side(s) {} void draw() override { std::cout << "Square"; } double area() override { return _side * _side; } }; ``` ```cpp Shape* shapes[2]; shapes[0] = new Circle(5.0); shapes[1] = new Square(3.0); shapes[0]->draw(); // prints "Circle" (dynamic resolution) shapes[1]->draw(); // prints "Square" (dynamic resolution) ``` --- ## כללי פולימורפיזם פולימורפיזם מתרחש כש**כל שלושת התנאים** מתקיימים: 1. המתודה נקראת דרך **מצביע או הפניה** למחלקת הבסיס 2. המתודה מוכרזת **`virtual`** במחלקת הבסיס 3. המחלקה הנגזרת **דורסת** את המתודה עם חתימה זהה בדיוק !!! warning "חיתוך אובייקטים (Object Slicing)" השמת אובייקט נגזר לאובייקט בסיס **לפי ערך** חותכת את החלק הנגזר: ```cpp Circle c(5.0); Shape s = c; // sliced -- s is just a Shape s.draw(); // calls Shape::draw(), NOT Circle::draw() ``` תמיד השתמשו במצביעים או הפניות לפולימורפיזם. --- ## מפרקים וירטואליים (Virtual Destructors) אם למחלקת בסיס יש מתודות וירטואליות, המפרק שלה **חייב** להיות וירטואלי: ```cpp class Base { public: virtual ~Base() { } // virtual destructor }; class Derived : public Base { int* _data; public: Derived() : _data(new int[100]) { } ~Derived() { delete[] _data; } }; Base* p = new Derived; delete p; // without virtual destructor, ~Derived() would NOT be called! ``` !!! tip "כלל פשוט" אם למחלקה שלכם יש **מתודה וירטואלית כלשהי**, הפכו את המפרק לוירטואלי. --- ## פונקציות וירטואליות טהורות ומחלקות מופשטות **פונקציה וירטואלית טהורה** (pure virtual) אין לה מימוש במחלקת הבסיס (מוכרזת עם `= 0`). מחלקה עם לפחות פונקציה וירטואלית טהורה אחת היא **מופשטת** (abstract) ולא ניתן ליצור ממנה מופעים. ```cpp class Shape { public: virtual void draw() = 0; // pure virtual virtual double area() = 0; // pure virtual virtual ~Shape() {} }; Shape s; // ERROR -- Shape is abstract Shape* p; // OK -- pointer to abstract class Circle c(5.0); // OK -- Circle implements all pure virtuals p = &c; // OK ``` !!! info "ממשקים (Interfaces)" מחלקות מופשטות משמשות כ**ממשקים** -- הן מגדירות מה מחלקות נגזרות חייבות לממש בלי לספק את המימוש בעצמן. --- ## מגדירי `override` ו-`final` (C++11) ### `override` אומר לקומפיילר שאתם מתכוונים לדרוס פונקציה וירטואלית. אם החתימות לא תואמות, הקומפיילר מדווח על שגיאה: ```cpp class Base { public: virtual void foo(float x); virtual void bar() const; }; class Derived : public Base { public: void foo(int x) override; // ERROR -- parameter type differs void bar() override; // ERROR -- missing const }; ``` ### `final` מונע ירושה ממחלקה או דריסה של מתודה: ```cpp class Base { public: virtual void foo() final; // cannot be overridden }; class Derived final : public Base // cannot be inherited { // void foo() override; // ERROR -- foo is final }; ``` --- ## טבלת וירטואלית (vtable) -- איך זה עובד לכל מחלקה עם מתודות וירטואליות יש **טבלה וירטואלית** (vtable) -- מערך של מצביעי פונקציות. כל אובייקט מאחסן מצביע נסתר לטבלה של המחלקה שלו. ``` Class A vtable: Class B vtable: ┌──────────────┐ ┌──────────────┐ │ A::F1 │ │ B::F1 │ ← overridden │ A::F2 │ │ A::F2 │ ← inherited └──────────────┘ │ B::F3 │ ← new └──────────────┘ Object a: [ vtable_ptr → A_vtable | a_ ] Object b: [ vtable_ptr → B_vtable | a_ | b_ ] ``` כשקוראים ל-`p->F1()`, זמן הריצה עוקב אחר מצביע ה-vtable כדי למצוא את הפונקציה הנכונה. --- ## סיכום | מושג | נקודות מפתח | |------|-------------| | ירושה | מחלקה נגזרת יורשת חברי מחלקת בסיס; השתמשו ב-`public` ליחסי "הוא-סוג-של" | | `virtual` | מאפשר dispatch דינמי (פולימורפיזם) | | וירטואלית טהורה (`= 0`) | הופכת מחלקה למופשטת; חייבת להיות ממומשת במחלקות נגזרות | | `override` | הכרזת דריסה נבדקת בקומפילציה (C++11) | | `final` | מונע דריסה נוספת או ירושה (C++11) | | מפרק וירטואלי | נדרש כשמוחקים אובייקטים נגזרים דרך מצביעי בסיס | | סדר בנייה | בסיס קודם, אחר כך חברים, אחר כך גוף הנגזרת | | סדר הרס | נגזרת קודם, אחר כך חברים, אחר כך בסיס |