- Previously,
we learned that the new
operator can be used to
create new class variables
Example:
class ListElem { int value; ListElem *next; }; ListElem *p; p = new ListElem;
- The new
operator can also
create an array
of any type.
Syntax:
new TYPE[ #elements ];
The new operator returns the address of the first variable of the new array
NOTE:
You should store the return value in a variable of the type: TYPE * x;
Example:
double *x; x = new double[100];
- We have previously studied an incredably rigid class
that contains a 3x3 matrix structure:
class Matrix3x3 { public: double A[3][3]; .... };
- We need 3 variables
to maintain information on the general shaped
matrix :
class Matrix { public: int M; // # rows int N; // # columns double *A; // matrix elements .... };
- The new
operator allows us
to define a more
general matrix class
- For simplicity, we will use square matrices in the remainder of the discussion....
- The following
CreateMatrix() function
allows the user to
define
an N x N matrix:
class MatrixNxN { public: int N; double *A; /* ------------------------------------------ CreateMatrix(n): reserve space for matrix ------------------------------------------ */ void CreateMatrix(int n) { A = new double[n*n]; // Reserve space for matrix N = n; // We must remember dimension // in order to access A[i][j] } } - The way to use it is
pretty ugly:
int main(int argc, char *argv[]) { int N; MatrixNxN m1; N = 4; // Remember the dimension m1.CreateMatrix(4); ... }
- Example Program:
(Demo above code)
- Prog file: click here
- Beside estethics there is a more
fundamental weakness
in this approach:
- The definition
of a variable
is incomplete
- The definition
MatrixNxN m1;
did NOT define a complete matrix
- Additional action is required to complete the definition
- The definition
of a variable
is incomplete
- Such multi step procedure will only invite programming errors
- Constructor function/method:
A constructor function/method (or constructor for short), is a special type of member function that is (only) invoked when a class variable is defined - In other words,
when we define a variable such as:
MatrixNxN m1; or MatrixNxN m2(5);
besides reserving the necessary memory to store the variable, a special constructor function will be invoked as well.
- Defining a constructor:
- A constructor
must have
the same name
as the class itself.
- A constructor
can have zero or more
parameters
- A constructor do NOT have a return type
Example:
class MatrixNxN { public: double *A; int N; /* ------------------------------------------ Constructor 1: does not create a matrix ------------------------------------------ */ MatrixNxN() { A = NULL; N = 0; } /* ------------------------------------------ Constructor 2: creates a nxn matrix ------------------------------------------ */ MatrixNxN(int n) { A = new double[n*n]; N = n; } ... };
- A constructor
must have
the same name
as the class itself.
- You can have
multiple constructors
in a class
The way that C++ determine which constructor to invoke is by the number and type of parameters specified with the variable definition Example:
MatrixNxN m1; // Invokes Constructor 1 (no parameter) MatrixNxN m2(4); // Invokes Constructor 2 (int) MatrixNxN m3[4]; // Invokes Constructor 1 four times MatrixNxN m4[4] = {MatrixNxN(2), MatrixNxN(3), MatrixNxN(4), MatrixNxN(5)}; // Invokes Constructor 2 four times
- Example Program:
(Demo above code)
- Prog file: click here
- Example Program:
(runnable program)
- Prog file: click here
|
- The default constructor
of a class is invoked (to initialized a class variable)
when a variable or an array
is defined
without any initial value
- The default constructor
is defined as:
class className { public: className() { ... // code for default constructor } ... }; - The default constructor
is invoked when variables are defined
as follows:
className var1; className var2[5];
- If you want to
initialize
a class variable using
another variable of the same class ,
then you must
define the following
constructor :
class className { public: className( className x ) { ... // code instruct C++ to initialize // variable using parameter x } ... }This constructor is known as the copy constructor
- The
copy constructor
is invoked when you define a variable using
one of the following constructs:
className a; className b = a; // initialize b using a or className b(a); // initialize b using a
- Example:
bad copy constructor
The following example show a common error when copying arrays (matrices)
class MatrixNxN { public: double *A; int N; // **** BAD copy constructor for a Matrix !!! MatrixNxN( MatrixNxN & a) { A = a.A; // Only copied the address !!! N = a.N; } ... };This constructor does NOT make another copy of the matrix
Instead, it make another copy of the address of the existing matrix
- Example Program:
(Demo above code)
- Prog file: click here
- We can see that the constructor
does NOT make another copy
of the matrix
because when
we change some elements in the
original matrix ,
then
copy is also changed
- Example:
good copy constructor
The following example show how to copy arrays (matrices)
class MatrixNxN { public: double *A; int N; // The right way to copy a Matrix MatrixNxN( MatrixNxN & a) { int i, j; A = new double(a.N * a.N); // Make a new array; N = a.N; for (i = 0; i < N; i = i + 1) for (j = 0; j < N; j = j + 1) A[i*N+j] = a.A[i*N+j]; // Copy elements } ... };
- Example Program:
(Demo above code)
- Prog file: click here
- Now, when
we change some elements in the
original matrix ,
copy is unchanged
- Some pre-requisites:
- Recall that the lifetime of a
local variable ends at the end
of its scope
(see click here ).
- Recall also the
new
operator reserve
unused memory locations
- Finally, recall that the reserve space is returned using the delete operator. (see click here ).
- Recall that the lifetime of a
local variable ends at the end
of its scope
(see click here ).
- Therefore:
If we define a MatrixNxN variable in some scope, and later exits that scope , then some reserved memory have not been "un-reserved" !!! Example:
- When f() returns, the memory space allocated to store the array A[4*4] have not been de-allocated
void f() { MatrixNxN m(4); // Allocate space for: // m.A // m.N // A[4*4] (using new in constructor) ... } // Deallocate space for: // m.A // m.N
int main(int argc, char *argv[]) { ... f(); ... }
- A straightforward way to free the reserve space
that was used to store the array
A[4*4]
is to provide an
"ordinary" member function :
class MatrixNxN { double *A; int N; /* ---------------------------------------------- FreeMatrix(): free reserve space for matrix ---------------------------------------------- */ void FreeMatrix() { delete A; } ... (other stuff) }
- The way to use it is again
very clumpsy :
void f() { MatrixNxN m(4); ... m.FreeMatrix(); // Deallocate space used for A[4*4] }
int main(int argc, char *argv[]) { ... f(); ... } - You must
invoke the function
explicitly
If you forget or does not know about it , then the program may run out of memory and crash...
- The destructor member function
(or destructor for short)
of a class
is a function that is
automatically invoked
when
a class variable goes
out of scope (and "dies")
- Just like a constructor,
a destructor
must have the same name
as the class itself, but
the name must be
preceeded with
the special character
"~"
- The destructor
does not have any parameters
- Example Destructor:
class MatrixNxN { public: double *A; int N; ~MatrixNxN() { if ( A != NULL ) { delete A; } } ... }
- Example Program:
(Shows that the destructor is invoked
automatrically )
- Prog file: click here
- Rule of thumb:
When you use a new operator in a constructor (to allocate space for some variable), you must provide a destructor to de-allocate the space allocated by the new operator