ירושה ב-C++

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

דוּגמָה: בדוגמה הבאה Animal היא מחלקת הבסיס וכלב חתול ופרה הם כיתות נגזרות שמרחיבות את מחלקת החיות.

Inheritance C++

    #include          using     namespace     std  ;   class     Animal   {      public  :      void     sound  ()      {      cout      < <     'Animal makes a sound'      < <     endl  ;      }   };   class     Dog     :     public     Animal   {      public  :      void     sound  ()      {      cout      < <     'Dog barks'      < <     endl  ;      }   };   class     Cat     :     public     Animal   {      public  :      void     sound  ()      {      cout      < <     'Cat meows'      < <     endl  ;      }   };   class     Cow     :     public     Animal   {      public  :      void     sound  ()      {      cout      < <     'Cow moos'      < <     endl  ;      }   };   int     main  ()   {      Dog     d  ;      d  .  sound  ();      Cat     c  ;      c  .  sound  ();      Cow     cow  ;      cow  .  sound  ();      return     0  ;   }

תְפוּקָה

Dog barks Cat meows Cow moos

הֶסבֵּר:

Animal היא מחלקת הבסיס עם פונקציה sound().
כלב חתול ופרה הם מחלקות נגזרות שכל אחת מגדירה את שיטת הסאונד() שלו.
ב-main() אובייקטים של Dog Cat ו-Cow נוצרים בנפרד.
כאשר אנו קוראים ל-sound() על כל אובייקט פועלת שיטת ה-child בהתאמה (כלב נובח Cat meows Cow moos).

תַחבִּיר

C++

    class     ChildClass     :     public     ParentClass   {      // Additional fields and methods   };

איך הירושה עובדת ב-C++?

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

סוגי ירושה ב-C++

להלן סוגי הירושה השונים הנתמכים על ידי C++.

1. ירושה בודדת

בירושה בודדת תת-מחלקה נגזרת ממעמד-על אחד בלבד. הוא יורש את המאפיינים וההתנהגות של מחלקה חד-הורית. לפעמים זה ידוע גם בתור ירושה פשוטה.

Single Inheritance C++

    #include          using     namespace     std  ;   class     Vehicle     {   public  :      Vehicle  ()     {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   class     Car     :     public     Vehicle     {   public  :      Car  ()     {      cout      < <     'This Vehicle is Car'      < <     endl  ;      }   };   int     main  ()     {          Car     obj  ;      return     0  ;   }

תְפוּקָה

This is a Vehicle This Vehicle is Car

2. ירושה מרובה

ב ירושה מרובה מחלקה אחת יכולה לכלול יותר מכיתה על אחת ולרשת תכונות מכל כיתות האב.

Multiple Inheritance C++

    #include          using     namespace     std  ;   class     LandVehicle   {      public  :      void     landInfo  ()      {      cout      < <     'This is a LandVehicle'      < <     endl  ;      }   };   class     WaterVehicle   {      public  :      void     waterInfo  ()      {      cout      < <     'This is a WaterVehicle'      < <     endl  ;      }   };   // Derived class inheriting from both base classes   class     AmphibiousVehicle     :     public     LandVehicle       public     WaterVehicle   {      public  :      AmphibiousVehicle  ()      {      cout      < <     'This is an AmphibiousVehicle'      < <     endl  ;      }   };   int     main  ()   {      AmphibiousVehicle     obj  ;      obj  .  waterInfo  ();      obj  .  landInfo  ();      return     0  ;   }

תְפוּקָה

This is an AmphibiousVehicle This is a WaterVehicle This is a LandVehicle

3. ירושה רב-שכבתית

ירושה רב-שכבתית ב-C++ פירושה מחלקה נגזרת ממחלקה נגזרת אחרת היוצרת שרשרת של ירושה.

Multilevel Inheritance C++

    #include          using     namespace     std  ;   class     Vehicle   {      public  :      Vehicle  ()      {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   // Derived class from Vehicle   class     FourWheeler     :     public     Vehicle   {      public  :      FourWheeler  ()      {      cout      < <     '4 Wheeler Vehicles'      < <     endl  ;      }   };   // Derived class from FourWheeler   class     Car     :     public     FourWheeler   {      public  :      Car  ()      {      cout      < <     'This 4 Wheeler Vehicle is a Car'      < <     endl  ;      }   };   int     main  ()   {      Car     obj  ;      return     0  ;   }

תְפוּקָה

This is a Vehicle 4 Wheeler Vehicles This 4 Wheeler Vehicle is a Car

4. ירושה היררכית

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

Hierarchical Inheritance C++

    #include          using     namespace     std  ;   class     Vehicle   {      public  :      Vehicle  ()      {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   class     Car     :     public     Vehicle   {      public  :      Car  ()      {      cout      < <     'This Vehicle is Car'      < <     endl  ;      }   };   class     Bus     :     public     Vehicle   {      public  :      Bus  ()      {      cout      < <     'This Vehicle is Bus'      < <     endl  ;      }   };   int     main  ()   {      Car     obj1  ;      Bus     obj2  ;      return     0  ;   }

תְפוּקָה

This is a Vehicle This Vehicle is Car This is a Vehicle This Vehicle is Bus

5. הורשה היברידית

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

Hybrid Inheritance C++

    #include          using     namespace     std  ;   class     Vehicle   {      public  :      Vehicle  ()      {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   class     Fare   {      public  :      Fare  ()      {      cout      < <     'Fare of Vehicle'      < <     endl  ;      }   };   class     Car     :     public     Vehicle   {      public  :      Car  ()      {      cout      < <     'This Vehical is a Car'      < <     endl  ;      }   };   class     Bus     :     public     Vehicle       public     Fare   {      public  :      Bus  ()      {      cout      < <     'This Vehicle is a Bus with Fare'  ;      }   };   int     main  ()   {      Bus     obj2  ;      return     0  ;   }

תְפוּקָה

This is a Vehicle Fare of Vehicle This Vehicle is a Bus with Fare

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

הערה: הפתרון הוא להשתמש בירושה וירטואלית כך שרק עותק בודד של מחלקת הבסיס משותף.

יתרונות ההורשה ב-C++

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

חסרונות של ירושה ב-C++

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