"Constructing" and "Destroying" Objects

Defining class objects of difference sizes
- We have previously studied an incredably rigid class that contains a 3x3 matrix structure:
- If we want to be able to define object (in this case: matrices) of different sizes, we cannot use constants inside the class defintion.
  In fact, the situation is worse in C++, because C++ requires that array definitions contains constants
  For example, this is NOT allows:
- Fortunately, the new operator does allow the use of variables:
  - The above code fragment will "create" (reserve space for) an N x N array.
  - We must use the linearized index A[i*N + j] to access the element A[i][j]

The simple-minded way to define class object of varying size

A simple-minded and straightforward way to "create" (reserve space) an N x N matrix is to use a member function:

class MatrixNxN { int N; float *A; /* ------------------------------------------ CreateMatrix(n): reserve space for matrix ------------------------------------------ */ void CreateMatrix(int n) { A = new float[n*n]; // Reserve space for matrix N = n; // We must remember dimension // in order to access A[i][j] } /* ------------------------------------ AddNum(x): add number to matrix ------------------------------------ */ void AddNum(float x) { int i, j; for (i = 0; i < N; i = i + 1) for (j = 0; j < N; j = j + 1) A[i*N+j] = A[i*N+j] + x; }; }

The way to use it is pretty clumpsy

int main(int argc, char *argv[]) { int N; MatrixNxN M; N = 4; M.CreateMatrix(N); ... }

First, an object M is defined
And then, the member function M.CreateMatrix(N) is invoked.

Example Program: (Dynamical allocation of a matrix object) ---- click here
WEAKNESS of this "classic" approach:
The separation of the definition of the object M and the required invocation of M.CreateMatrix(N) create the possibility for PROGRAMMER ERROR:

Constructor: a special type of member function

The SUPERIOR way to define a MatrixNxN object is enforcing space reservation for the N x N matrix at the moment that a MatrixNxN variable is defined !

The structure of this superior approach looks as follows:

int main(int argc, char *argv[]) { int N = 4; MatrixNxN M(N); // Also reserve space for NxN matrix ... }

Object Oriented programming languages (C++, Java) provide the constructor mechanism to realise this feature
A constructor is a special type of member function
A constructor must have the same name as the class itself.

We can rewrite CreateMatrix() into a constructor as follows:

class MatrixNxN { .... void CreateMatrix(int n) { A = new float[n*n]; N = n; } .... }

class MatrixNxN { .... MatrixNxN(int n) // Constructor { A = new float[n*n]; N = n; } .... }

Example Program: (Constructor) ---- click here

There are a number of famous constructors...

Famous constructor 1: the default constructor
- The default constructor for a class is invoked to initialized a class variable when a class variable is defined without any initial value;
- There is always one default constructor for every class.
  C++ provides a simple default constructor to you; but you can replace the provided default constructor with a more suitable one if necessary.
  The default constructor provided by C++ will allocate space for all variables defined in a class.
- Defining your own default constructor:
  - Example Program: (DEFAULT Constructor) ---- click here
CAVEAT on the default constructor
- Make sure you understand the difference between the following 2 expressions:
  int main(int argc, char *argv[]) { MatrixNxN f; .... }
  
  int main(int argc, char *argv[]) { MatrixNxN f(); .... }
- MatrixNxN f; defines an uninitialized variable of type MatrixNxN
  This definition will invoke the default constructor
- MatrixNxN f(); in many C++ compilers, this expression would declare a function f that takes no parameter and returns an MatrixNxN variable.
  A more explicit way to write this is: extern MatrixNxN f();, and I would encourage you to do this...

Famous constructor 2: the copy constructor

The copy constructor for a class is invoked to initialized a class variable when a class variable is initialized using another variable of that class;

There are 2 possible syntax constructs for initializating a class variable using another class variable of the same type:

Copy constructor syntax 1:
class MatrixNxN { int N; float *A; ... } MatrixNxN a; ... (give components in ... "a" some value) MatrixNxN b(a); // Define b and // initialize b // with variable a
Copy constructor syntax 2:
class MatrixNxN { int N; float *A; ... } MatrixNxN a; ... (give components in ... "a" some value) MatrixNxN b = a;

There is also always one copy constructor for every class.
C++ provides a simple copy constructor to you; and again, you can replace the provided copy constructor with a more suitable one if necessary.
The copy constructor provided by C++ will allocate space for all variables defined in a class and then copy all values in the supplied class variable to the new variable.
Example Program: (C++'s default COPY Constructor) ---- click here
- Can you explain why the output is like this ???
  Hint: think about "call-by-reference"...

Defining your own copy constructor:

From the previous program, you can obviously see that the default copy constructor provided by C++ is inadequate to initialize a new MatrixNxN variable - because the new variable does NOT have its own array !!!

It is necessary to provide our own copy constructor.

The syntax to define a copy constructor is as follows:

class MatrixNxN { .... MatrixNxN(MatrixNxN & x) // Copy Constructor: // one MatrixNxN parameter { .... use x to initialize the new MatrixNxN variable } .... }

NOTE: the input parameter can be passed in by value, but since we do NOT change the input parameter inside a copy-constructor (at least, you must not), it is a customary practice to pass the input parameter by reference.

Example Program: (Your own COPY Constructor) ---- click here
- Notice the different between this true copy and the previous "reference to the old MatrixNxN variable".

Cleaning up reserved space: motivation for destructor

Recall that the lifetime of a local variable ends at the end of its scope (see click here ).
Recall also that variables created with the new operator persists (i.e., continues to exist) until the variable is "destroyed" using the delete operator.

So if we define a MatrixNxN variable in some inner scope, then leave that scope as illustrated in the following example:

int main(int argc, char *argv[]) { .... { int N; MatrixNxN M; N = 4; M.CreateMatrix(N); ... } }

We will have created a nice array with new but we have never dispose the array with delete: you have created some garbage without you even know that you did...

The simple-minded way to free up memory space

A straightforward way to free the reserve space for an N x N matrix is to use another member function:

class MatrixNxN { int N; float *A; /* ---------------------------------------------- FreeMatrix(): free reserve space for matrix ---------------------------------------------- */ void FreeMatrix() { delete A; } ... (other stuff) }

The way to use it is again pretty clumpsy:

int main(int argc, char *argv[]) { .... { int N; MatrixNxN M; N = 4; M.CreateMatrix(N); ... M.FreeMatrix(); // You have to remember // to do this or your program // is toasted... !!! } }

WEAKNESS of this "classic" approach:
Relies completely on human's ability to "remember to do it"
There's gotta be a better way... and there is...

Destructor: yet another special type of member function

The SUPERIOR way to deallocate memory space for the array in a MatrixNxN object is enforcing space deallocation at the moment that a MatrixNxN variable is destroyed !
The enforcement is achieved by the use of another special type of member functions called destructors
A destructor member function is invoked automatically when a class variable goes out of scope (and "dies")
Just like a constructor, a destructor member function must have the same name as the class itself, preceeded with the special character "~"

We can rewrite FreeMatrix() into a destructor as follows:

class MatrixNxN { .... void FreeMatrix() { delete A; } .... }

class MatrixNxN { .... ~MatrixNxN() // Destructor { delete A; } .... }

Example Program: (Destructor is called automatically) ---- click here

Rule of thumb...
- Although it is not immediately evident, there is a very strong relationship between a copy constructor and the destructor functions
- If you ponder a little bit on the question why do we NEED a copy constructor and CANNOT use the default copy constructor, you will understand why....
- C++ has already provide a default copy constructor that will be sufficient in many instances
  Recall the default copy constructor will copy ALL variables from one variable into the variable of another variable
- There is one common case where the default copy constructor will fail to work correctly and you will NEED to write your own copy constructor (and replace the C++ default copy constructor):
  That is when the copy constructor must copy values from variable OTHER THAN variables defined in the class
  Such variables can only be allocated dynamically !!!
- Therefore, if you NEED to write a copy constructor, then you must have allocated some memory using new.
  Consequently, when you destroy the class variable, you CANNOT simply use the default destructor;
  You NEED to write a customized destructor to free the allocated memory !!!
- Rule of thumb: