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

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

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; }

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.

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

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.

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

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

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;
}

RectangleUsage.cpp

#include <iostream>
using namespace std;
#include "Rectangle.hpp"
 
int main() {
  Rectangle rect {1, 2};
  Rectangle *r1, *r2, *r3;
  r1 = &rect;
  r2 = new Rectangle {2};
  r3 = new Rectangle[2] { {3,4}, {5} };
 
  cout << "---------------" << endl;
  Rectangle **r4;
  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 << "*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 << "r4[0]'s getArea: " << r4[0]->getArea() << endl;
  cout << "r4[1]'s getArea: " << r4[1]->getArea() << endl;
 
  cout << "---------------" << endl;
  delete r2;
  delete[] r3;
 
  cout << "---------------" << endl;
  delete r4[0];
  delete r4[1];
  delete []r4;
  return 0;
}	

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

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