Differences

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

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