Η δημιουργία αντικειμένων γίνεται με κλήση του αντίστοιχου κατασκευαστή ως εξής:

Rectangle.cpp

#include <iostream>
using namespace std;
 
class Rectangle {
  private:
    int width, height;
  public:
    Rectangle(int w, int h);
    Rectangle(int s);
    Rectangle();
    int getWidth() const;
    int getHeight() const;
    void setWidth(int w);
    void setHeight(int h);
};
 
Rectangle::Rectangle(int w, int h): width(w), height(h) {}
Rectangle::Rectangle(int s) : width(s), height(s) {}
Rectangle::Rectangle(): width(0), height(0) {}
 
int Rectangle::getWidth() const { return width;}
int Rectangle::getHeight() const { return height;}
void Rectangle::setWidth(int w) { width = w; }
void Rectangle::setHeight(int h) { height = h; }
 
int main() {
  Rectangle rect1(3,4);
  Rectangle rect2(5);
  Rectangle rect3;
}

Ο παραπάνω κώδικας δημιουργεί 3 αντικείμενα της κλάσης Rectangle το αντικείμενο rect1 με πλευρές 3 και 4, το rect2 με πλευρές κοινού μήκους 5 και το αντικείμενο rect3 που έχει μηδενικές τιμές.

Rectangle rect3(); // this is an error

Εκτός από την χρήση παρενθέσεων για την κλήση του καστασκευαστή της κλάσης όταν αυτός έχει ορίσματα υπάρχουν οι παρακάτω επιπλέον τρόποι κλήσης κατασκευαστών:

Στην περίπτωση που έχουμε μόνο μία παράμετρο μπορούμε να καλέσουμε τον κατασκευαστή της κλάσης με χρήση του τελεστή ίσον ('=') ως εξής:

class_name object_name = initialization_value;

Για παράδειγμα, για την κλάση Rectangle στη συνάρτηση main μπορείτε να γράψετε

int main () {
  Rectangle rect=5;
  cout << "area: " << rect.getWidth() * rect.getHeight() << endl;
  return 0;
}

Σε αυτή την περίτπωση καλείται ο κατασκευαστής που έχει ένα μόνο όρισμα το οποίο λαμβάνει την τιμή 5. Το εμβαδό του παραλληλογράμμου που εκτυπώνεται είναι 25 (5×5).

Η C++ δίνει την δυνατότητα χρήσης αγκύλων αντί για παρενθέσεις προκειμένου να καλέσουμε τον κατασκευαστή της κλάσης. Ο τρόπος αυτός έχει τις εξής δύο παραλαγές:

int main () {
  Rectangle rect {5,6}; // calls Rectangle(int w, int h)
  cout << "area: " << rect.getWidth() * rect.getHeight() << endl;
  return 0;
}

Καλείται ο κατασκευαστής της κλάσης με δύο ορίσματα (width=5, height=6).

int main () {
  Rectangle rect = {5,6}; // calls Rectangle(int w, int h)
  Rectangle rects[2] = {{4,5}, {5,6}}; // calls Rectangle(int w, int h) for each table element
  cout << "[rect    ] area: " << rect.getWidth() * rect.getHeight() << endl;
  cout << "[rects[0]] area: " << rects[0].getWidth() * rects[0].getHeight() << endl;
  cout << "[rects[1]] area: " << rects[1].getWidth() * rects[1].getHeight() << endl;
  return 0;
}

Οι παραπάνω δύο τρόποι είναι ισοδύναμοι εάν πρόκειται να αρχικοποιήσουμε ένα μεμονομένο αντικείμενο. Στην περίπτωση που θέλουμε να αρχικοποιήσουμε πίνακες από αντικείμενα, μόνο η χρήση του τελεστή ίσον ('=') πριν από τις αγκύλες επιτρέπει την παραπάνω αρχικοποίηση σε μία εντολή.

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

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

foo.cpp

#include <iostream>
using namespace std;
#include "Rectangle.cpp"
 
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;
  foo();
  cout << "x: " << x << ", y: " << y << endl;
}

Ακολουθεί το σχηματικό διάγραμμα του stack της διεργασίας πριν, κατά τη διάρκεια και μετά την εκτέλεσης της συνάρτησης foo.

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

foo.cpp

#include <iostream>
using namespace std;
#include "Rectangle.cpp"
 
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. για τα r2, r3 είμαστε υποχρεωμένοι να ελευθερώσουμε τη μνήμη που δεσμεύτηκε στο heap κατά τη δημιουργία των αντικειμένων.

Rectangle.cpp

#include <iostream>
#include <cstdlib>
using namespace std;
 
class Rectangle {
  private:
    int *width, *height;
  public:
    Rectangle(int w, int h);
    ~Rectangle();
    void setWidth(int w);
    void setHeight(int h);
    int getWidth();
    int getHeight();
    int getArea();
};
 
Rectangle::Rectangle(int w, int h) {
  width = new (nothrow) int;    
  height = new (nothrow) int;
  if(width == NULL || height == NULL) {
    cerr << "Memory allocation failure!\n";
    exit(-1);
  }
  *width = w; *height = h;
  cout << "Constructing rectangle (w:"<< *width <<", h:"<<*height<<")\n";
}
 
Rectangle::~Rectangle() {
  cout << "Destructing rectangle (w:"<< *width <<", h:"<<*height<<")\n";
  delete width;
  delete height;
}
 
void Rectangle::setWidth(int w) { *width = w; }
void Rectangle::setHeight(int h) { *height = h; }
int Rectangle::getWidth() { return *width; }
int Rectangle::getHeight() { return *height; }
int Rectangle::getArea() { return *width * *height; }

RectangleUsage.cpp

#include <iostream>
using namespace std;
#include "Rectangle.cpp"
 
int main() {
  Rectangle rect {3, 4};
  Rectangle *r1, *r2, *r3;
  r1 = &rect;
  r2 = new Rectangle {5, 6};
  r3 = new Rectangle[2] { {4,8}, {7,3} };
  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;       
  delete r2;
  delete[] r3;
  return 0;
}