Παρακάτω δίνεται ο κώδικας της κλάσης Rectangle τον οποίο θα χρησιμοποιήσουμε για να μεταγλωττίσουμε και να εκτελέσουμε τα παραδείγματα που ακολουθούν. Η παρούσα κλάση αποτελείται από δύο πεδία τύπου int* (για την αποθήκευση του width και του height αντιστοίχως). Κατά την κατασκευή ενός αντικειμένου θα πρέπει απαραίτητα να δεσμεύεται ο απαιτούμενος χώρος για την αποθήκευση των τιμών του πλάτους και του ύψους. Κατά την καταστροφή του αντικειμένου ο χώρος που δεσμεύτηκε θα πρέπει να αποδεσμευτεί στον καταστροφέα.

Rectangle.hpp

class Rectangle {
  private:
    int *width_ptr, *height_ptr;
  public:
    Rectangle();
    Rectangle(int w, int h);
    Rectangle(int s);
    ~Rectangle();
    void setWidth(int w);
    void setHeight(int h);
    int getWidth();
    int getHeight();
    int getArea();
};

Rectangle.cpp

#include <iostream>
#include <cstdlib>
#include "Rectangle.hpp"
 
using namespace std;
 
Rectangle::Rectangle() {
  width_ptr = new (nothrow) int;    
  height_ptr = new (nothrow) int;
  if(width_ptr == NULL || height_ptr == NULL) {
    cerr << "Memory allocation failure!\n";
    exit(-1);
  }
  *width_ptr = *height_ptr = 0;
  cout << "Calling 0 args constructor" << endl;
}
 
Rectangle::Rectangle(int w, int h) : Rectangle() {
  *width_ptr = w;
  *height_ptr = h;
  cout << "Calling 2 args constructor" << endl;
}
 
Rectangle::Rectangle(int s) : Rectangle(s,s) {
  cout << "Calling 1 args constructor" << endl;
}
 
Rectangle::~Rectangle() {
  cout << "Destructing rectangle (w:"<< *width_ptr <<", h:"<<*height_ptr<<")\n";
  delete width_ptr;
  delete height_ptr;
}
 
void Rectangle::setWidth(int w) { *width_ptr = w; }
void Rectangle::setHeight(int h) { *height_ptr = h; }
int Rectangle::getWidth() { return *width_ptr; }
int Rectangle::getHeight() { return *height_ptr; }
int Rectangle::getArea() { return *width_ptr * *height_ptr; }

Rectangle::Rectangle(int w, int h) : Rectangle() {
  *width_ptr = w;
  *height_ptr = h;
  cout << "Calling 2 args constructor" << endl;
}

Rectangle::Rectangle(int w, int h) {
  Rectangle();
  *width_ptr = w;
  *height_ptr = h;
  cout << "Calling 2 args constructor" << endl;
}

Τα αντικείμενα στο τρέχον παράδειγμα αποθηκεύονται μέσα στη στοίβα (stack) της συνάρτησης που καλεί τον κατασκευαστή της. Τα αντικείμενα αυτά έχουν χρόνο ζωής όσο εκτελείται η συγκεκριμένη συνάρτηση και η στοίβα της είναι ενεργή. Μόλις επιστρέψουμε από την συνάρτηση που δημιουργεί το οποιοδήποτε αντικείμενο, αυτό καταστρέφεται αυτόματα. Εάν συντρέχουν λόγοι εκκαθάρισης μνήμης ή περιγραφέων αρχείων οφείλουμε να ορίσουμε καταστροφέα για τη συγκεκριμένη κλάση, όπως κάναμε για την κλάση Rectangle.

Παρακάτω δίνεται ο κώδικας της συνάρτησης foo η οποία δημιουργεί ένα πίνακα από δύο αντικείμενα τύπου Rectangle. Τα αντικείμενα δημιουργούνται στο stack της διεργασίας που εκτελείται και έχουν χρόνο ζωής όσο διαρκεί η εκτέλεση της συνάρτησης foo. Μετά την έξοδο από την foo τα αντικείμενα rect[0] και rect[1] καταστρέφονται. Η κλάση Rectangle που δημιουργείται δίνεται παρακάτω:

foo.cpp

#include <iostream>
using namespace std;
#include "Rectangle.hpp"
 
void foo(void) {
  Rectangle rect[2] = { {5,6}, {3,4} };
  cout << "rect[0] area: " << rect[0].getArea() << endl;
  cout << "rect[1] area: " << rect[1].getArea() << endl;
}
 
int main() {
  int x=5, y=3;
  cout << "x: " << x << ", y: " << y << endl;
  foo();
  cout << "x: " << x << ", y: " << y << endl;
}

Ακολουθεί το σχηματικό διάγραμμα του stack της διεργασίας πριν, κατά τη διάρκεια και μετά την εκτέλεσης της συνάρτησης foo. Μεταγλωττίζοντας και εκτελώντας τον παραπάνω κώδικα, μπορείτε να δείτε τα μηνύματα που εκτυπώνονται και να διαπιστώσετε ότι τα δύο αντικείμενα τύπου Rectangle καταστρέφονται κατά την έξοδο από τη foo. Στο διάγραμμα δεν αποτυπώνεται η δέσμευση μνήμης για τα πεδία του κάθε αντικειμένου τύπου Rectangle.

Υπάρχουν περιπτώσεις που θέλουμε να ορίσουμε ένα αντικείμενο το οποίο θα παραμείνει και μετά την έξοδο από τη συνάρτηση που το δημιούργησε. Σε αυτές τις περιπτώσεις πρέπει α) να ορίσουμε ένα δείκτη του τύπου του αντικείμενου που θέλουμε να δημιουργήσουμε και β) να δεσμεύσουμε την απαραίτητη μνήμη και να αρχικοποιήσουμε το αντικείμενο μέσω του τελεστή new. Παρακάτω βλέπετε ένα παράδειγμα όπου η συνάρτηση foo επιστρέφει ένα δείκτη σε αντικείμενο της κλάσης Rectangle που δημιουργήθηκε στο heap.

foo.cpp

#include <iostream>
using namespace std;
#include "Rectangle.hpp"
 
Rectangle* foo(int w, int h) {
  Rectangle* rect_ptr = new Rectangle {w,h};
  return rect_ptr;
}
 
int main() {
  int x=5, y=3;
  Rectangle* rect = foo(x,y);
  cout << "x: " << x << ", y: " << y << endl;
  cout << "area : " << rect->getArea() << endl;
  delete rect;
}

Ακολουθεί το σχηματικό διάγραμμα του stack και του heap της διεργασίας πριν, κατά τη διάρκεια και μετά την εκτέλεσης της συνάρτησης foo. Στο διάγραμμα δεν αποτυπώνεται η δέσμευση μνήμης για τα πεδία width και height του κάθε αντικειμένου τύπου Rectangle.

Όταν δεν χρειαζόμαστε πλέον το αντικείμενο που δεσμεύτηκε δυναμικά στο heap θα πρέπει να το καταστρέψουμε ελευθερώνοντας τη δεσμευμένη μνήμη με τη βοήθεια του τελεστή delete. Κατά την απελευθέρωση της μνήμης μέσω του τελεστή delete καλείται ο καταστροφέας της κλάσης, σε αναλογία με την κλήση του κατασκευαστή της κλάσης με χρήση του τελεστή new.

Παρακάτω δίνεται η κλάση Rectangle και ένα παράδειγμα αρχικοποίησης των τριών δεικτών r1, r2, r3 τύπου Rectangle, οι οποίοι αρχικοποιούνται ως εξής:

1. ο δείκτης r1 δείχνει στο αντικείμενο r.
2. ο δείκτης r2 δείχνει σε ένα αντικείμενο που αρχικοποιείται στο heap.
3. ο δείκτης r3 δείχνει σε ένα πίνακα από αντικείμενα που αρχικοποιείται επίσης στο heap.
4. πριν την ολοκλήρωση του προγράμματος πρέπει να ελευθερώσουμε τη μνήμη που δεσμεύτηκε στο heap κατά τη δημιουργία των αντικειμένων στα οποία δείχνουν οι δείκτες r2, r3 και r4.

RectangleUsage-1.cpp

#include <iostream>
using namespace std;
#include "Rectangle.hpp"
 
/* Δημιουργώ ένα αντικείμενο 'r' στο stack και
 * 1. ένα δείκτη που δείχνει στο 'r'
 * 2. ένα δείκτη που δείχνει σε ένα δυναμικά 
 *    δεσμευμένο αντικείμενο.
 * 3. ένα δείκτη που δείχνει σε δυναμικά 
 *    δεσμευμένο μονοδιάστατο πίνακα.
 * */
 
int main() {
  Rectangle r {1, 2};
  Rectangle *r1, *r2, *r3;
  cout << "--- init r1 ---" << endl;
  r1 = &r;
  cout << "--- init r2 ---" << endl;
  r2 = new Rectangle {2};
  cout << "--- init r3 ---" << endl;
  r3 = new Rectangle[2] {{3,4}, {5}};
 
  cout << "---------------" << endl;
  cout << "r's  getArea: " << r.getArea() << endl;
  cout << "*r1's   getArea: " << r1->getArea() << endl;
  cout << "*r2's   getArea: " << r2->getArea() << endl;
  cout << "r3[0]'s getArea: " << r3[0].getArea() << endl;
  cout << "r3[1]'s getArea: " << r3[1].getArea() << endl;       
 
  cout << "---------------" << endl;
  delete r2;
  delete[] r3;
 
  return 0;
}

Μεταγλωττίστε και εκτελέστε τον παραπάνω κώδικα. Η έξοδος θα είναι η εξής:

Calling 0 args constructor
Calling 2 args constructor
--- init r1 ---
--- init r2 ---
Calling 0 args constructor
Calling 1 args constructor
--- init r3 ---
Calling 0 args constructor
Calling 2 args constructor
Calling 0 args constructor
Calling 1 args constructor
---------------
r's  getArea: 2
*r1's   getArea: 2
*r2's   getArea: 4
r3[0]'s getArea: 12
r3[1]'s getArea: 25
---------------
Destructing rectangle (w:2, h:2)
Destructing rectangle (w:5, h:5)
Destructing rectangle (w:3, h:4)
Destructing rectangle (w:1, h:2)

Παρατηρήστε ότι στον πίνακα r3 πρώτα καταστρέφεται το αντικείμενο r3[1] και στη συνέχεια το αντικείμενο r3[0].

Παρακάτω δίνεται η κλάση Rectangle και ο δείκτης σε δείκτη τύπου Rectangle r4, μέσω του οποίου δημιουργούμε ένα διδιάστατο πίνακα από ορθογώνια παραλληλόγραμμα. Η πρώτη γραμμή του πίνακα έχει δύο στήλες και η δεύτερη γραμμή τρεις στήλες. Πριν την ολοκλήρωση του προγράμματος πρέπε και πάλι να ελευθερώσουμε τη μνήμη που δεσμεύτηκε στο heap κατά τη δημιουργία των αντικειμένων στα οποία δείχνουν οι ενδιάμεσοι δείκτες που δημιουργούνται και ο δείκτης r4.

RectangleUsage-2.cpp

#include <iostream>
using namespace std;
#include "Rectangle.hpp"
 
/* Δημιουργώ ένα δυναμικά δεσμευμένο 
 * διδιάστατο πίνακα από αντικείμενα 
 * τύπου Rectangle.
 */
 
int main() {
 
  Rectangle **r4;
  cout << "--- init r4 ---" << endl;
  r4 = new Rectangle*[2];
  cout << "--- init r4[0] ---" << endl;
  r4[0] = new Rectangle[2] {{5,6}, {7,8}};
  cout << "--- init r4[1] ---" << endl;
  r4[1] = new Rectangle[3] {{9}, {10}, {11,10}};
 
  cout << "---------------" << endl;
  cout << "r4[0][0]'s getArea: " << r4[0][0].getArea() << endl;
  cout << "r4[0][1]'s getArea: " << r4[0][1].getArea() << endl;
  cout << "r4[1][0]'s getArea: " << r4[1][0].getArea() << endl;
  cout << "r4[1][1]'s getArea: " << r4[1][1].getArea() << endl;
  cout << "r4[1][2]'s getArea: " << r4[1][2].getArea() << endl;
  cout << "---------------" << endl;
 
  delete[] r4[0];  // Call the destructor of Rectangle for all elements in row 0.
  delete[] r4[1];  // Call the destructor of Rectangle for all elements in row 1.
  delete[] r4;
}