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

User Tools

Site Tools

Trace:
cpp:object_lifecycle

Differences

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

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
Next revisionBoth sides next revision
cpp:object_lifecycle [2020/04/14 08:50] – gthanoscpp:object_lifecycle [2020/04/14 14:00] – gthanos
Line 2: Line 2:
 ====== Κύκλος ζωής των αντικειμένων - Δημιουργία και ανάθεση αντικειμένων στο heap ====== ====== Κύκλος ζωής των αντικειμένων - Δημιουργία και ανάθεση αντικειμένων στο heap ======
  
-Τα αντικείμενα που φτιάξαμε μέχρι τώρα αποθηκεύονται μέσα στη στοίβα (//stack//) της συνάρτησης που καλεί τον κατασκευαστή της. Τα αντικείμενα αυτά έχουν χρόνο ζωής όσο εκτελείται η συγκεκριμένη συνάρτηση και η στοίβα της είναι ενεργή. Μόλις επιστρέψουμε από την συνάρτηση που δημιουργεί το οποιοδήποτε αντικείμενο, αυτό καταστρέφεται αυτόματα. Εάν συντρέχουν λόγοι εκκαθάρισης μνήμης ή περιγραφέων αρχείων οφείλουμε να ορίσουμε καταστροφέα για τη συγκεκριμένη κλάση. +Παρακάτω δίνεται ο κώδικας της κλάσης //Rectangle// τον οποίο θα χρησιμοποιήσουμε για να μεταγλωττίσουμε και να εκτελέσουμε τα παραδείγματα που ακολουθούν. Η παρούσα κλάση αποτελείται από δύο πεδία τύπου int* (για την αποθήκευση του width και του height αντιστοίχως). Κατά την κατασκευή ενός αντικειμένου θα πρέπει απαραίτητα να δεσμεύεται ο απαιτούμενος χώρος για την αποθήκευση των τιμών του πλάτους και του ύψους. Κατά την καταστροφή του αντικειμένου ο χώρος που δεσμεύτηκε θα πρέπει να αποδεσμευθεί στον καταστροφέα.
- +
-Παρακάτω δίνεται ο κώδικας της συνάρτησης //foo// η οποία δημιουργεί ένα πίνακα από δύο αντικείμενα τύπου //Rectangle//. Τα αντικείμενα δημιουργούνται στο //stack// της διεργασίας που εκτελείται και έχουν χρόνο ζωής όσο διαρκεί η εκτέλεση της συνάρτησης //foo//. Μετά την έξοδο από την //foo// τα αντικείμενα //rect[0]// και //rect[1]// καταστρέφονται. Η κλάση Rectangle που δημιουργείται δίνεται παρακάτω:+
  
 <code cpp Rectangle.hpp> <code cpp Rectangle.hpp>
-#include <iostream> 
-#include <cstdlib> 
-using namespace std; 
  
 class Rectangle { class Rectangle {
Line 28: Line 23:
  
 <code cpp Rectangle.cpp> <code cpp Rectangle.cpp>
 +#include <iostream>
 +#include <cstdlib>
 #include "Rectangle.hpp" #include "Rectangle.hpp"
 +
 +using namespace std;
  
 Rectangle::Rectangle() { Rectangle::Rectangle() {
Line 63: Line 62:
 int Rectangle::getArea() { return *width_ptr * *height_ptr; } int Rectangle::getArea() { return *width_ptr * *height_ptr; }
 </code> </code>
 +
 +<WRAP tip 80% round>
 +Παρατηρήστε τον τρόπο με τον οποίο καλείται κατασκευαστής χωρίς ορίσματα από τους άλλους κατασκευαστές. Η κλήση ενός κατασκευαστή από έναν άλλο είναι δυνατή στη C++ με χρήση του ονόματος της κλάσης. Γενικότερα, η κλήση μπορεί να γίνει είτε στο //member initialization list//, είτε μέσα στο σώμα του κατασκευαστή. Για παράδειγμα
 +<code cpp>
 +Rectangle::Rectangle(int w, int h) : Rectangle() {
 +  *width_ptr = w;
 +  *height_ptr = h;
 +  cout << "Calling 2 args constructor" << endl;
 +}
 +</code>
 +ή ισοδύναμα
 +<code cpp>
 +Rectangle::Rectangle(int w, int h) {
 +  Rectangle();
 +  *width_ptr = w;
 +  *height_ptr = h;
 +  cout << "Calling 2 args constructor" << endl;
 +}
 +</code>
 +</WRAP>
 +
 +===== 1η Περίπτωση - Δημιουργία αντικειμένων στο Stack =====
 +
 +Τα αντικείμενα στο τρέχον παράδειγμα αποθηκεύονται μέσα στη στοίβα (//stack//) της συνάρτησης που καλεί τον κατασκευαστή της. Τα αντικείμενα αυτά έχουν χρόνο ζωής όσο εκτελείται η συγκεκριμένη συνάρτηση και η στοίβα της είναι ενεργή. Μόλις επιστρέψουμε από την συνάρτηση που δημιουργεί το οποιοδήποτε αντικείμενο, αυτό καταστρέφεται αυτόματα. Εάν συντρέχουν λόγοι εκκαθάρισης μνήμης ή περιγραφέων αρχείων οφείλουμε να ορίσουμε καταστροφέα για τη συγκεκριμένη κλάση, όπως κάναμε για την κλάση //Rectangle//.
 +
 +Παρακάτω δίνεται ο κώδικας της συνάρτησης //foo// η οποία δημιουργεί ένα πίνακα από δύο αντικείμενα τύπου //Rectangle//. Τα αντικείμενα δημιουργούνται στο //stack// της διεργασίας που εκτελείται και έχουν χρόνο ζωής όσο διαρκεί η εκτέλεση της συνάρτησης //foo//. Μετά την έξοδο από την //foo// τα αντικείμενα //rect[0]// και //rect[1]// καταστρέφονται. Η κλάση Rectangle που δημιουργείται δίνεται παρακάτω:
  
 <code cpp foo.cpp> <code cpp foo.cpp>
Line 83: Line 108:
 </code> </code>
  
-Ακολουθεί το σχηματικό διάγραμμα του //stack// της διεργασίας πριν, κατά τη διάρκεια και μετά την εκτέλεσης της συνάρτησης //foo//.+Ακολουθεί το σχηματικό διάγραμμα του //stack// της διεργασίας πριν, κατά τη διάρκεια και μετά την εκτέλεσης της συνάρτησης //foo//. Μεταγλωττίζοντας και εκτελώντας τον παραπάνω κώδικα, μπορείτε να δείτε τα μηνύματα που εκτυπώνονται και να διαπιστώσετε ότι τα δύο αντικείμενα τύπου //Rectangle// καταστρέφονται κατά την έξοδο από τη //foo//. Στο διάγραμμα δεν αποτυπώνεται η δέσμευση μνήμης για τα πεδία του κάθε αντικειμένου τύπου //Rectangle//.
  
 {{ :cpp:cppstackonly.png | Σχηματικό διάγραμμα του stack της διεργασίας πριν, κατά τη διάρκεια και μετά την εκτέλεσης της συνάρτησης foo}} {{ :cpp:cppstackonly.png | Σχηματικό διάγραμμα του stack της διεργασίας πριν, κατά τη διάρκεια και μετά την εκτέλεσης της συνάρτησης foo}}
  
-Υπάρχουν όμως περιπτώσεις που θέλουμε να ορίσουμε ένα αντικείμενο το οποίο θα παραμείνει και μετά την έξοδο από τη συνάρτηση που το δημιούργησε. Σε αυτές τις περιπτώσεις αρκεί να ορίσουμε ένα δείκτη προς το αντικείμενο και να το αρχικοποιήσουμε με τη βοήθεια του τελεστή //new//. Μέσω του τελεστή //new// έχουμε την δυνατότητα να δεσμεύσουμε τον απαραίτητο χώρο στο //heap// και παράλληλα να καλέσουμε τον κατάλληλο κατασκευαστή του αντικειμένου για την αρχικοποίηση του. Παρακάτω βλέπετε ένα παράδειγμα όπου η συνάρτηση //foo// επιστρέφει ένα αντικείμενο της κλάσης //Rectangle//.+===== 2η Περίπτωση - Δημιουργία αντικειμένων στο Heap ===== 
 + 
 +Υπάρχουν περιπτώσεις που θέλουμε να ορίσουμε ένα αντικείμενο το οποίο θα παραμείνει και μετά την έξοδο από τη συνάρτηση που το δημιούργησε. Σε αυτές τις περιπτώσεις πρέπει α) να ορίσουμε ένα δείκτη του τύπου του αντικείμενου που θέλουμε να δημιουργήσουμε και β) να δεσμεύσουμε την απαραίτητη μνήμη και να αρχικοποιήσουμε το αντικείμενο μέσω του τελεστή //new//. Παρακάτω βλέπετε ένα παράδειγμα όπου η συνάρτηση //foo// επιστρέφει ένα δείκτη σε αντικείμενο της κλάσης //Rectangle// που δημιουργήθηκε στο //heap//.
  
 <code cpp foo.cpp> <code cpp foo.cpp>
Line 95: Line 122:
  
 Rectangle* foo(int w, int h) { Rectangle* foo(int w, int h) {
-  Rectangle *rect_ptr = new Rectangle {w,h};+  Rectangle* rect_ptr = new Rectangle {w,h};
   return rect_ptr;   return rect_ptr;
 } }
Line 101: Line 128:
 int main() { int main() {
   int x=5, y=3;   int x=5, y=3;
-  Rectangle *rect = foo(x,y);+  Rectangle* rect = foo(x,y);
   cout << "x: " << x << ", y: " << y << endl;   cout << "x: " << x << ", y: " << y << endl;
   cout << "area : " << rect->getArea() << endl;   cout << "area : " << rect->getArea() << endl;
Line 108: Line 135:
 </code> </code>
  
-Ακολουθεί το σχηματικό διάγραμμα του //stack// και του //heap// της διεργασίας πριν, κατά τη διάρκεια και μετά την εκτέλεσης της συνάρτησης //foo//.+Όταν δεν χρειαζόμαστε πλέον το αντικείμενο που δεσμεύτηκε δυναμικά στο //heap// θα πρέπει να το καταστρέψουμε ελευθερώνοντας τη δεσμευμένη μνήμη με τη βοήθεια του τελεστή //delete//. Κατά την  απελευθέρωση της μνήμης μέσω του τελεστή //delete// καλείται ο καταστροφέας της κλάσης, σε αναλογία με την κλήση του κατασκευαστή της κλάσης με χρήση του τελεστή //new//.   
 + 
 +Ακολουθεί το σχηματικό διάγραμμα του //stack// και του //heap// της διεργασίας πριν, κατά τη διάρκεια και μετά την εκτέλεσης της συνάρτησης //foo//. Στο διάγραμμα δεν αποτυπώνεται η δέσμευση μνήμης για τα πεδία //width// και //height// του κάθε αντικειμένου τύπου //Rectangle//.
  
 {{ :cpp:cppstackheap.png | Σχηματικό διάγραμμα του stack και του heap της διεργασίας πριν, κατά τη διάρκεια και μετά την εκτέλεσης της συνάρτησης foo}} {{ :cpp:cppstackheap.png | Σχηματικό διάγραμμα του stack και του heap της διεργασίας πριν, κατά τη διάρκεια και μετά την εκτέλεσης της συνάρτησης foo}}
  
-===== Παράδειγμα αρχικοποίησης δεικτών =====+===== Ένα πιο σύνθετο παράδειγμα αρχικοποίησης δεικτών =====
  
-Παρακάτω δίνεται η κλάση //Rectangle// και ένα παράδειγμα αρχικοποίησης των τριών δεικτών r1, r2, r3 τύπου //Rectangle//, οι οποίοι αρχικοποιούνται ως εξής: +Παρακάτω δίνεται η κλάση //Rectangle// και ένα παράδειγμα αρχικοποίησης των τριών δεικτών //r1, r2, r3// τύπου //Rectangle//, οι οποίοι αρχικοποιούνται ως εξής: 
-  - ο δείκτης //r1// δείχνει στο αντικείμενο rect.+  - ο δείκτης //r1// δείχνει στο αντικείμενο //r//.
   - ο δείκτης //r2// δείχνει σε ένα αντικείμενο που αρχικοποιείται στο //heap//.   - ο δείκτης //r2// δείχνει σε ένα αντικείμενο που αρχικοποιείται στο //heap//.
   - ο δείκτης //r3// δείχνει σε ένα πίνακα από αντικείμενα που αρχικοποιείται επίσης στο //heap//.   - ο δείκτης //r3// δείχνει σε ένα πίνακα από αντικείμενα που αρχικοποιείται επίσης στο //heap//.
Line 121: Line 150:
   - πριν την ολοκλήρωση του προγράμματος είμαστε υποχρεωμένοι να ελευθερώσουμε τη μνήμη που δεσμεύτηκε στο //heap// κατά τη δημιουργία των αντικειμένων στα οποία δείχνουν οι δείκτες //r2, r3 και r4//.   - πριν την ολοκλήρωση του προγράμματος είμαστε υποχρεωμένοι να ελευθερώσουμε τη μνήμη που δεσμεύτηκε στο //heap// κατά τη δημιουργία των αντικειμένων στα οποία δείχνουν οι δείκτες //r2, r3 και r4//.
  
-<WRAP tip 80% round> 
-Παρατηρήστε τον τρόπο με τον οποίο καλείται κατασκευαστής χωρίς ορίσματα από τους άλλους κατασκευαστές. Η κλήση ενός κατασκευαστή από έναν άλλο είναι δυνατή στη C++ με χρήση του ονόματος της κλάσης. Γενικότερα, η κλήση μπορεί να γίνει είτε στο //member initialization list//, είτε μέσα στο σώμα του κατασκευαστή. Για παράδειγμα 
-<code cpp> 
-Rectangle::Rectangle(int w, int h) : Rectangle() { 
-  *width_ptr = w; 
-  *height_ptr = h; 
-  cout << "Calling 2 args constructor" << endl; 
-} 
-</code> 
-ή ισοδύναμα 
-<code cpp> 
-Rectangle::Rectangle(int w, int h) { 
-  Rectangle(); 
-  *width_ptr = w; 
-  *height_ptr = h; 
-  cout << "Calling 2 args constructor" << endl; 
-} 
-</code> 
-</WRAP> 
  
-<code cpp RectangleUsage.cpp>+<code cpp RectangleUsage1.cpp>
 #include <iostream> #include <iostream>
 using namespace std; using namespace std;
 #include "Rectangle.hpp" #include "Rectangle.hpp"
 +
 +/* Δημιουργώ ένα αντικείμενο 'r' στο stack και
 + * 1. ένα δείκτη που δείχνει στο 'r'
 + * 2. ένα δείκτη που δείχνει σε ένα δυναμικά 
 + *    δεσμευμένο αντικείμενο.
 + * 3. ένα δείκτη που δείχνει σε δυναμικά 
 + *    δεσμευμένο μονοδιάστατο πίνακα.
 + * */
  
 int main() { int main() {
-  Rectangle rect {1, 2};+  Rectangle r {1, 2};
   Rectangle *r1, *r2, *r3;   Rectangle *r1, *r2, *r3;
-  r1 = &rect;+  cout << "--- init r1 ---" << endl; 
 +  r1 = &r; 
 +  cout << "--- init r2 ---" << endl;
   r2 = new Rectangle {2};   r2 = new Rectangle {2};
-  r3 = new Rectangle[2] { {3,4}, {5} };+  cout << "--- init r3 ---" << endl; 
 +  r3 = new Rectangle[2] {{3,4}, {5}};
      
   cout << "---------------" << endl;   cout << "---------------" << endl;
-  Rectangle **r4; +  cout << "r's  getArea: " << r.getArea() << endl;
-  r4 = new Rectangle*[2]; +
-  r4[0] = new Rectangle {6}; +
-  r4[1] = new Rectangle (2,6); +
-   +
-  cout << "---------------" << endl; +
-  cout << "rect's  getArea: " << rect.getArea() << endl;+
   cout << "*r1's   getArea: " << r1->getArea() << endl;   cout << "*r1's   getArea: " << r1->getArea() << endl;
   cout << "*r2's   getArea: " << r2->getArea() << endl;   cout << "*r2's   getArea: " << r2->getArea() << endl;
   cout << "r3[0]'s getArea: " << r3[0].getArea() << endl;   cout << "r3[0]'s getArea: " << r3[0].getArea() << endl;
   cout << "r3[1]'s getArea: " << r3[1].getArea() << endl;          cout << "r3[1]'s getArea: " << r3[1].getArea() << endl;       
-  cout << "r4[0]'s getArea: " << r4[0]->getArea() << endl; 
-  cout << "r4[1]'s getArea: " << r4[1]->getArea() << endl; 
      
   cout << "---------------" << endl;   cout << "---------------" << endl;
Line 172: Line 185:
   delete[] r3;   delete[] r3;
      
-  cout << "---------------" << endl; 
-  delete r4[0]; 
-  delete r4[1]; 
-  delete []r4; 
   return 0;   return 0;
-} +} 
 </code> </code>
  
Line 184: Line 194:
 Calling 0 args constructor Calling 0 args constructor
 Calling 2 args constructor Calling 2 args constructor
 +--- init r1 ---
 +--- init r2 ---
 Calling 0 args constructor Calling 0 args constructor
-Calling 2 args constructor 
 Calling 1 args constructor Calling 1 args constructor
 +--- init r3 ---
 Calling 0 args constructor Calling 0 args constructor
 Calling 2 args constructor Calling 2 args constructor
 Calling 0 args constructor Calling 0 args constructor
-Calling 2 args constructor 
 Calling 1 args constructor Calling 1 args constructor
 --------------- ---------------
-Calling 0 args constructor +r's  getArea: 2
-Calling 2 args constructor +
-Calling 1 args constructor +
-Calling 0 args constructor +
-Calling 2 args constructor +
---------------- +
-rect's  getArea: 2+
 *r1's   getArea: 2 *r1's   getArea: 2
 *r2's   getArea: 4 *r2's   getArea: 4
 r3[0]'s getArea: 12 r3[0]'s getArea: 12
 r3[1]'s getArea: 25 r3[1]'s getArea: 25
-r4[0]'s getArea: 36 
-r4[1]'s getArea: 12 
 --------------- ---------------
 Destructing rectangle (w:2, h:2) Destructing rectangle (w:2, h:2)
 Destructing rectangle (w:5, h:5) Destructing rectangle (w:5, h:5)
 Destructing rectangle (w:3, h:4) Destructing rectangle (w:3, h:4)
---------------- 
-Destructing rectangle (w:6, h:6) 
-Destructing rectangle (w:2, h:6) 
 Destructing rectangle (w:1, h:2) Destructing rectangle (w:1, h:2)
 </code> </code>
 +
 +===== Ένα ακόμη πιο σύνθετο παράδειγμα αρχικοποίησης δεικτών =====
 +
 +Παρακάτω δίνεται η κλάση //Rectangle// και ο δείκτης σε δείκτη τύπου //Rectangle// //r4//. Πριν την ολοκλήρωση του προγράμματος είμαστε και πάλι υποχρεωμένοι να ελευθερώσουμε τη μνήμη που δεσμεύτηκε στο //heap// κατά τη δημιουργία των αντικειμένων στα οποία δείχνουν οι ενδιάμεσοι δείκτες που δημιουργούνται και ο δείκτης //r4//.
  
  
cpp/object_lifecycle.txt · Last modified: 2021/05/07 06:35 (external edit)