LAB#06: Constructors & Destructors

CL 103 - COMPUTER PROGRAMMING LAB

 CONSTRUCTORS

Recall the following:

A constructor is a special function that is a member of a class.

 C++ requires a constructor call for each object that’s created, which helps ensure that each
object is initialized properly before it’s used in a program. The constructor call occurs implicitly
when the object is created. This ensures that objects will always have valid data to work on.
 Normally, constructors are declared public.
 Constructors can be overloaded, just like other functions.

DIFFERENCE BETWEEN CONSTRUCTORS AND OTHER FUNCTIONS

 A constructor must be defined with the same name as the class.
 Constructors do not possess a return type (not even void).

DEFAULT CONSTRUCTOR

 A constructor without parameters is referred to as a default constructor.

 If a class does not contain a constructor definition, the compiler will create a minimal version of
the default constructor as a public member. However, this constructor will not perform
initialization. An uninitialized variable typically contains a “garbage” value.
 By contrast, if a class contains at least one constructor, a default constructor must be defined
explicitly.

CONSTRUCTOR OVERLOADING

When two or more functions share the same name, the function name is said to be overloaded. Any
class member function may be overloaded, including the constructor. One constructor might take an
integer argument, for example, while another constructor takes a double.

POINTER TYPE DECLARATION

1 LAB#03 : POINTERS & DYNAMIC MEMORY MANAGEMENT IN C++

SYNTAX: type * variable ;

EXAMPLE: int *ptr, char * character, float * greatvalue;

EXPLANATION: The value of the pointer variable ptr is a memory address. A data item whose
address is stored in this variable must be of the specified type.

POINTERS AND ARRAYS

The identifier of an array is equivalent to the address of its first element, as a pointer is equivalent to the
address of the first element that it points to.

EXAMPLE: Assume the following declaration:

int numbers [20];
int * p;

The following assignment operation would be valid:

p = numbers;

2 LAB#03 : POINTERS & DYNAMIC MEMORY MANAGEMENT IN C++

POINTER INITIALIZATION

When declaring pointers we can explicitly specify which variable we want them to point to.

EXAMPLE: int number;

int *tommy = &number;

The above code is equivalent to:

int number;
int *tommy;
tommy = &number;

We can also initialize the content at which the pointer points with constants at the same moment the
pointer is declared:

EXAMPLE: char * terry = "fast";

Assuming that "fast" is stored at the memory locations that start at addresses 1702, we can represent the
previous declaration as:

3 LAB#03 : POINTERS & DYNAMIC MEMORY MANAGEMENT IN C++

POINTER ARITHMETIC

Only addition and subtraction operations are allowed with pointers. Furthermore, when incrementing a
pointer, the size in bytes of the type pointed to is added to the pointer.

EXAMPLE: char *mychar; //points to memory location 1000

short *myshort; //points to memory location 2000
long *mylong; //points to memory location 3000

mychar++; //mychar now contains 1001

myshort++; //myshort now contains 2002
mylong++; //mylong now contains 3004

POINTERS TO POINTERS (DOUBLE POINTER)

C++ allows the use of pointers that point to pointers, that these, in its turn, point to data (or even to other
pointers). In order to do that, we only need to add an asterisk (*) for each level of reference in their
declarations:

EXAMPLE: char a;
char * b;
char ** c;

a = 'z';
b = &a;
c = &b;

This, supposing the randomly chosen memory locations for each variable of 7230, 8092 and 10502, could
be represented as:

 c has type char** and a value of 8092

 *c has type char* and a value of 7230
 **c has type char and a value of 'z'

4 LAB#03 : POINTERS & DYNAMIC MEMORY MANAGEMENT IN C++

VOID POINTER

Void pointers are pointers that can point to any data type. One limitation of void pointers is that they
cannot be directly de-referenced.

EXAMPLE:

NULL POINTER
A null pointer is a regular pointer of any pointer type which has a special value that indicates that it is not
pointing to any valid reference or memory address.

EXAMPLE: int * p;
p = 0; // p has a null pointer value

Do not confuse null pointers with void pointers. A null pointer is a value that any pointer may take to
represent that it is pointing to "nowhere", while a void pointer is a special type of pointer that can point to
somewhere without a specific type.

5 LAB#03 : POINTERS & DYNAMIC MEMORY MANAGEMENT IN C++

POINTERS TO FUNCTIONS

C++ allows operations with pointers to functions. The typical use of this is for passing a function as an
argument to another function, since these cannot be passed de-referenced.

EXAMPLE:

6 LAB#03 : POINTERS & DYNAMIC MEMORY MANAGEMENT IN C++

 DYNAMIC MEMORY ALLOCATION
Dynamic memory allocation is needed if we want a variable amount of memory that can only be
determined during runtime.

OPERATORS new & new[ ]

In order to request dynamic memory we use the operator new, which is followed by a data type
specifier and optional brackets [ ] (if a sequence of more than one element is required).

SYNTAX: variable = new type

variable = new type [no. of elements]

EXAMPLE: int * bobby;

bobby = new int [5];

In this example, the system dynamically assigns space for five elements of type int and returns a pointer
to the first element of the sequence, which is assigned to bobby. Therefore, now, bobby points to a valid
block of memory with space for five elements of type int.

The first element pointed by bobby can be accessed either with the expression bobby[0] or the
expression *bobby. Both are equivalent as has been explained in the section about pointers. The second
element can be accessed either with bobby[1] or *(bobby+1) and so on.

OPERATORS delete & delete[ ]

To free dynamic memory after it is used, delete operator is used so that the memory becomes available
again for other requests of dynamic memory.

SYNTAX: delete variable;

delete[ ] variable;

7 LAB#03 : POINTERS & DYNAMIC MEMORY MANAGEMENT IN C++

EXAMPLE:

8 LAB#03 : POINTERS & DYNAMIC MEMORY MANAGEMENT IN C++