LAB#03: POINTERS AND DYNAMIC MEMORY

MANAGEMENT IN C++
CL 103 - COMPUTER PROGRAMMING LAB
 POINTERS
Pointer is a variable whose value is a memory address. Normally, a variable directly contains a specific
value. A pointer contains the memory address of a variable that, in turn, contains a specific value. In this
sense, a variable name directly references a value, and a pointer indirectly references a value.

REFERENCE OPERATOR ( & )

The address that locates a variable within memory is what we call a reference to that variable.

ted = &andy;

assume that andy is placed during runtime in the memory address 1776.

andy = 25;
fred = andy;
ted = &andy;

The values contained in each variable after the execution of this, are shown in the following diagram:

DE-REFERENCE OPERATOR ( * )
The asterisk (*) acts as a dereference operator and that can be translated to "value pointed by".

beth = *ted;

We could read as: "beth equal to value pointed by ted", beth would take the value 25, since ted is 1776,
and the value pointed by 1776 is 25.

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

POINTER TYPE DECLARATION

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++