Αντικειμενοστραφής Προγραμματισμός

User Tools

Site Tools

Trace: • pointers • operator_overloading • multiple_inheritance • associative_containers • class_templates_specialization • object_creation • strings • vector_overloading_binary_operators2 • namespace • inheritance
cpp:inheritance

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision 		Previous revision
cpp:inheritance [2017/04/22 09:51]
gthanos [Άλλες μορφές κληρονομικότητας] 		cpp:inheritance [2022/05/13 07:01] (current)
gthanos [Κληρονομικότητα]
Line 1: Line 1:
 ====== Κληρονομικότητα ====== ====== Κληρονομικότητα ======
  
-====== Κληρονομικότητα ======+Οι κλάσεις στη C++ μπορούν να επεκταθούν μέσω της κληρονομικότητας, δημιουργώντας νέες κλάσεις που διατηρούν τα χαρακτηριστικά των προγόνων τους. Η κληρονομικότητα προϋποθέτει ότι υπάρχει η βασική κλάση (πρόγονος) από την οποία προκύπτουν μία ή περισσότερες κλάσεις (απόγονοι). Οι απόγονοι διατηρούν τα χαρακτηριστικά του προγόνου, αλλά έχουν την δυνατότητα να προσθέσουν και επιπλέον χαρακτηριστικά στη νέα κλάση.
  
-Σε αναλογία με τη Java, οι κλάσεις στη C++ μπορούν να επεκταθούν μέσω της κληρονομικότητας, δημιουργώντας νέες κλάσεις που διατηρούν τα χαρακτηριστικά των προγόνων τους. Η κληρονομικότητα προϋποθέτει ότι υπάρχει η βασική κλάση (πρόγονος) από την οποία προκύπτουν μία ή περισσότερες κλάσεις (απόγονοι). Οι απόγονοι διατηρούν τα χαρακτηριστικά του προγόνου, αλλά έχουν την δυνατότητα να προσθέσουν και επιπλέον χαρακτηριστικά στη νέα κλάση.+Στο παρακάτω παράδειγμα, από την κλάση //Shape// (διδιάστατο σχήμα) προκύπτει η κλάση //Rectangle// (ορθογώνιο παραλληλόγραμμο). Η κλάση //Shape// ορίζει την //private// μεταβλητή //color// που αφορά το χρώμα του σχήματος, το οποίο αποθηκεύεται σε μορφή [[wp>RGB]] και την //protected// μεταβλητή //borderWidth// που αφορά το πάχος του πλαισίου γύρο από το σχήμα.
  
-Στο παρακάτω παράδειγμα, από την κλάση //Rectangle// (ορθογώνιο παραλλολόγραμμο) προκύπτει η κλάση //Square// (τετράγωνο). Η κλάση //Square// εκτός των διαστάσεων του τετραγώνου ορίζει μία επιπλέον παράμετρο //color// που αφορά το χρώμα του τετραγώνου και το οποίο αποθηκεύεται σε μορφή [[wp>RGB]]. +<code cpp Shape.hpp> 
- +class Shape { 
-<code cpp Rectangle.cpp> +    unsigned int color;
-#include <iostream> +
-using namespace std; +
- +
-class Rectangle { +
-  private: +
-    int width;+
   protected:   protected:
-    int height;+    unsigned char borderWidth;
   public:   public:
-    Rectangle(int w, int h); +    Shape(unsigned int c, unsigned char bw); 
-    bool equals(Rectangle &r); +    Shape(unsigned char red, unsigned char blue, unsigned char green, unsigned char bw); 
-    void setWidth(int w); +    void setColor(unsigned int c); 
-    void setHeight(int h); +    void setColor(unsigned char red, unsigned char blue, unsigned char green); 
-    int getWidth(); +    unsigned int getColor(); 
-    int getHeight();+    unsigned int getArea();
 }; };
- 
-Rectangle::Rectangle(int w, int h) { 
-  width = w; height = h; 
-} 
- 
-bool Rectangle::equals(Rectangle &r) { 
-  if(r.width == width && r.height == height) 
-    return true; 
-  return false; 
-} 
- 
-void Rectangle::setWidth(int w) { width = w; } 
-void Rectangle::setHeight(int h) { height = h; } 
-int Rectangle::getWidth() { return width; } 
-int Rectangle::getHeight() { return height; } 
 </code> </code>
  
-<code cpp Square.cpp> +<code cpp Shape.cpp> 
-#include "Rectangle.cpp"+#include <iostream> 
 +using namespace std;
  
-class Square: public Rectangle { +#include "Shape.hpp"
-   int color; +
-   public: +
-     Square(int s); +
-     bool equals(Square &s); +
-     void setColor(int c); +
-     void setColor(unsigned char r, unsigned char b, unsigned char g); +
-     int getColor(); +
-     int getArea(); +
-};+
  
-Square::Square(int s) : Rectangle(s,s) {} +void Shape::setColor(unsigned int c) { color = c; } 
-void Square::setColor(int c) { color = c; } +void Shape::setColor(unsigned char red, unsigned char blue, unsigned char green) {
-void Square::setColor(unsigned char red, unsigned char blue, unsigned char green) {+
   color = red;   color = red;
   color <<= 8;   color <<= 8;
Line 65: Line 35:
 } }
  
-int Square::getColor() {+unsigned int Shape::getColor() {
   return color;   return color;
 } }
  
-int Square::getArea() { +Shape::Shape(unsigned int c, unsigned char bw) : color(c), borderWidth(bw) {
-  // height is accessible from Square +
-  // since it is a protected member. +
-  return getWidth() * height; +
 } }
  
-bool Square::equals(Square &s) { +Shape::Shape(unsigned char red, unsigned char blue, unsigned char green, unsigned char bw) : borderWidth(bw) { 
-   if( Rectangle::equals(s) && s.color == color) +  setColor(red, blue, green);
-     return true; +
-   return false;+
 } }
-</code> 
  
-<code cpp SquareUsage.cpp> +unsigned int Shape::getArea() {
-#include "Square.cpp" +
- +
-int main() { +
-  Square square(5); +
-  cout << "Square dimensions: [" << square.getWidth() <<"," << square.getHeight() << "]\n"; +
-  cout << "Square area: " << square.getArea() << endl;+
   return 0;   return 0;
 } }
 </code> </code>
  
-Από τα παραπάνω παρατηρούμε τα εξής: +<code cpp Rectangle.hpp> 
-  - Η κληρονομικότητα δηλώνεται μέσω της δήλωσης ''class derived_class_name : public base_class_name { /*...*/ };'' (στο παραπάνω παράδειγμα ''class Square: public Rectangle { };''). +#include "Shape.hpp"
-  - Τα μέλη της γονικής κλάσης //Rectangle// που είναι δηλωμένα ως //protected// είναι προσβάσιμα από την απόγονο κλάση //Square//. Τα μέλη της γονικής κλάσης //Rectangle// που είναι δηλωμένα ως //private// δεν είναι προσβάσιμα από την απόγονο κλάση //Square//. +
-  - Όπως και στη Java, τα μέλη της γονικής κλάσης //Rectangle// ή της απογόνου κλάσης Square που είναι δηλωμένα ως //public// είναι προσβάσιμα από οποιαδήποτε κλάση ή μέθοδο.+
  
-Συνοπτικά ο πίνακας προσβασιμότητας παρατίθεται παρακάτω: +class Rectangle : public Shape { 
-^                  ^  μέλη της γονικής κλάσης  ^^^ +  private: 
-^  προσβασιμότητα  ^  public  ^  protected  ^  private  ^ +    unsigned int width, height;   
-| μέλη της ίδιας κλάσης  |  ναι  |  ναι  |  ναι  | +  public: 
-| μέλη υποκλάσης  |  ναι  |  ναι  |  όχι   | +    Rectangle(unsigned int c, unsigned char bw, unsigned int w, unsigned int h); 
-| μη μέλη της κλάσης  |  ναι  |  όχι  |  όχι  |+    void setWidth(unsigned int w); 
 +    void setHeight(unsigned int h); 
 +    unsigned int getWidth(); 
 +    unsigned int getHeight(); 
 +    unsigned int getArea(); 
 +     
 +    unsigned char getBorderWidth(); 
 +    void setBorderWidth(unsigned char bw); 
 +}; 
 +</code>
  
-<WRAP center round info 80%> +<code cpp Rectangle.cpp> 
-Όταν μία κλάση έχει πρόσβαση σε ένα πεδίο, το πεδίο αυτό δεν είναι προσβάσιμο μόνο για το τρέχον αντικείμενο, αλλά και για όλα αντικείμενα του τύπου της κλάσης. Στο παραπάνω παράδειγμα, η μέθοδος //equals// στις κλάσεις //Rectangle// και //Square// έχει πρόσβαση στα πεδία του αντικειμένου της μεθόδου που λαμβάνεται ως όρισμα. +#include <iostream> 
-</WRAP>+using namespace std;
  
-<WRAP center round info 80%> +#include "Rectangle.hpp"
-Όταν η απόγονος κλάση επαναορίζει μία μέθοδο με το ίδιο signature (ίδιο όνομα, ίδιος αριθμός και τύπος ορισμάτων) τότε συχνά θέλουμε να χρησιμοποιήσουμε τη γονική μέθοδο προκειμένου να την επεκτείνουμε. Ο τρόπος χρήσης της γονικής μεθόδου είναι βάζοντας ως πρόθεμα στη μέθοδο το όνομα της γονικής κλάσης. Ο λόγος που δεν υπάρχει κάποια δεσμευμένη λέξη (όπως ο τελεστής //super// στη Java) που να αναφέρεται στη γονική κλάση είναι η πολλαπλή κληρονομικότητα που επιτρέπει η C++. Από το παραπάνω παράδειγμα, δείτε την υλοποίηση της //equals// στην κλάση //Square//. +
-<code cpp> +
-  bool Square::equals(Square &s) { +
-    if( Rectangle::equals(s) && s.color == color) +
-      return true; +
-    return false; +
-  } +
-</code> +
-</WRAP>+
  
-===== Άλλες μορφές κληρονομικότητας =====+Rectangle::Rectangle(unsigned int c, unsigned char bw, unsigned int w, unsigned int h) :  
 +  Shape(c, bw) , width(w), height(h) { }
  
-Εκτός από την κληρονομικότητα τύπου //public// (''class Square: public Rectangle { };'') μπορείτε να έχετε κληρονομικότητα τύπου //protected// και //private//. Σε αυτές τις περιπτώσεις η προσβασιμότητα των πεδίων της γονικής κλάσης δίνεται από τον παραπάνω πίνακα +void Rectangle::setWidth(unsigned int w) { width = w; } 
-^   ^  είδος κληρονομικότητας  ^^^ +void Rectangle::setHeight(unsigned int h) { height = h; } 
-^  μέλη της γονικής κλάσης  ^  public  ^  protected  ^  private  ^ +unsigned int Rectangle::getWidth() { return width; } 
-| public μέλη  |  public  |  protected  |  not accessible  | +unsigned int Rectangle::getHeight() { return height; }
-| protected μέλη  |  protected  |  protected  |  not accessible   | +
-| private μέλη  |  not accessible  |  not accessible  |  not accessible  |+
  
-Δείτε το παρακάτω παράδειγμα που παραθέτει αναλυτικά τα επίπεδα της προσβασιμότητας+unsigned int Rectangle::getArea() { 
 +  /* this is how you call a function  
 +   * from the parent class. 
 +   */ 
 +  int area = Shape::getArea(); 
 +  return Shape::getArea() + width * height; 
 +}
  
-<code cpp> +unsigned char Rectangle::getBorderWidth() { return borderWidth; } 
-class Parent { +void Rectangle::setBorderWidth(unsigned char bw) { borderWidth = bw; } 
-public: +</code>
-    int publicMember; +
-protected: +
-    int protectedMember; +
-private: +
-    int privateMember; +
-};+
  
-class ChildA : public Parent { +<code cpp RectangleUsage.cpp> 
-    // publicMember is public +#include "Rectangle.hpp" 
-    // protectedMember is protected +#include <iostream> 
-    // privateMember is not accessible from ChildA +using namespace std;
-};+
  
-class ChildB : protected Parent { +int main() { 
-    // publicMember is protected +  Rectangle rectangle(0xffffff, 2, 10, 20); 
-    // protectedMember is protected +  rectangle.setBorderWidth(8); 
-    // privateMember is not accessible from ChildB +   
-}; +  cout << "[Rectangle Properties] "; 
- +  cout << " color: 0x" << std::hex << rectangle.getColor() << dec; 
-class ChildC : private Parent {   // 'private' is default for classes +  cout << " borderWidth: " << (int)rectangle.getBorderWidth(); 
-    // publicMember is private (accessible) +  cout << " area: " << rectangle.getArea() << endl; 
-    // protectedMember is private  (accessible) +   
-    // privateMember is not accessible from ChildC +  return 0; 
-};+}
 </code> </code>
  
-Στο παραπάνω παράδειγμα συμπερασματικά θα μπορούσαμε να πούμε τα εξής: +Από τα παραπάνω παρατηρούμε τα εξής: 
-  * Για την κλάση //ChildA// (//public// κληρονομικότητα) οποιαδήποτε κλάση γνωρίζει ότι η //ChildA// είναι απόγονος της //Parent//. +  - Η κληρονομικότητα δηλώνεται μέσω της δήλωσης ''class derived_class_name : public base_class_name { /*...*/ };'' (στο παραπάνω παράδειγμα ''class Rectangle: public Shape { };''). 
-  * Για την κλάση //ChildB// (//protected// κληρονομικότητα), μόνο η κλάση //ChildB// και η απόγονοι αυτής γνωρίζει ότι η //ChildB// είναι απόγονος της //Parent//. +  - Η απόγονος κλάση μπορεί να ορίσει επιπλέον πεδία και επιπλέον μεθόδους. Η απόγονος κλάση //Rectangle// ορίζει τα επιπλέον πεδία //width, height// και τις επιπλέον μεθόδους //getWidth//, //getHeight//, //setWidth//, //setHeight//. 
-  * Για την κλάση //ChildC// (//private// κληρονομικότητα), μόνο η κλάση //ChildC// γνωρίζει ότι η //ChildC// είναι απόγονος της //Parent//.+  - Η απόγονος κλάση μπορεί να επαναορίσει μία μέθοδο η οποία είναι ήδη ορισμένη στη γονική κλάση. Η απόγονος κλάση //Rectangle// επαναορίζει τη μέθοδο //getArea//. 
 +  - Τα μέλη της γονικής κλάσης //Shape// που είναι δηλωμένα ως //protected// είναι προσβάσιμα από την απόγονο κλάση. Στο παραπάνω παράδειγμα η απόγονος κλάση //Rectangle// έχει πρόσβαση στο //protected// πεδίο //borderWidth// της γονικής κλάσης.  
 +  - Τα μέλη της γονικής κλάσης //Shape// που είναι δηλωμένα ως //private// δεν είναι προσβάσιμα από την απόγονο κλάση //Rectangle//. 
 +  - Όπως και στη Java, τα μέλη της γονικής κλάσης //Shape// ή της απογόνου κλάσης //Rectangle// που είναι δηλωμένα ως //public// είναι προσβάσιμα από οποιαδήποτε κλάση ή μέθοδο. Για παράδειγμα η //public// μεθόδος //getColor// της κλάσης //Shape// είναι προσβάσιμη από οποιοδήποτε κλάση ή μέθοδο (στο παράδειγμα από τη μέθοδο main).
  
-<WRAP center round tip 80%> +Συνοπτικά ο πίνακας προσβασιμότητας παρατίθεται παρακάτω: 
-Η κληρονομικότητα τύπου //private// ή //protected// έχει περιορισμένη χρήση. +^                  ^  μέλη της γονικής κλάσης  ^^^ 
-</WRAP>+^  προσβασιμότητα  ^  public  ^  protected  ^  private  ^ 
 +| από μεθόδους της ίδιας κλάσης  |  ναι  |  ναι  |  ναι  | 
 +| από μεθόδους μίας υποκλάσης  |  ναι  |  ναι  |  όχι   | 
 +| από μία άλλη κλάση χωρίς σχέση κληρονομικότητας  |  ναι  |  όχι  |  όχι  |
  
 +===== Κλήση μιας επανα-ορισμένης μεθόδου της γονικής κλάσης από την υποκλάση =====
  
 +Όταν η απόγονος κλάση επαναορίζει μία μέθοδο με το ίδιο //signature// (ίδιο όνομα, ίδιος αριθμός και τύπος ορισμάτων) τότε συχνά θέλουμε να καλέσουμε τη μέθοδο της γονικής κλάσης στην απόγονο κλάση προκειμένου να την επεκτείνουμε. Ο τρόπος κλήσης της γονικής μεθόδου είναι βάζοντας ως πρόθεμα στο όνομα της μεθόδου το όνομα της γονικής κλάσης. Από το παραπάνω παράδειγμα, δείτε την υλοποίηση της συνάρτησης //getArea// στην κλάση //Rectangle// η οποία χρησιμοποιεί την συνάρτηση //getArea// της γονικής κλάσης //Shape//.
 +<code cpp>
 +unsigned int Rectangle::getArea() {
 +  return Shape::getArea() + width * height;
 +}
 +</code>
  
  
cpp/inheritance.1492854714.txt.gz · Last modified: 2017/04/22 08:51 (external edit)

Page Tools

Except where otherwise noted, content on this wiki is licensed under the following license: CC Attribution 4.0 International
CC Attribution 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki