Instructions:

Consider the following C$++$ program. It asks the user for the sizes of two dynamic arrays, and initializes these arrays to contain the values $17$ and $42$ respectively.

$//$ Include statements

#include

#include

using namespace std;

$//$ Main function

int main$()$

$\{$

$//$ Get user input

int size$1=0$;

cout $<<$ "Enter size of array$1$:

$"$;

cin $>>$ size$1$;

if $($size$1<0)$

size$1=0$;

$//$ Get user input

int size$2=0$;

cout $<<$ "Enter size of array$2$:

$"$;

cin $>>$ size$2$;

if $($size$2<0)$

size$2=0$;

$//$ Process array$1$

int $*$ array$1=$ new int$[$size$1]$;

cout $<<$ "array$1$:

$"$;

for $($int i $=0$; i $<$ size$1$; i$++)$

$\{$

array$1[$i$]=17$;

cout $<<$ array$1[$i$]<<""$;

$\}$

cout $<<$ endl;

$//$ Location A

$//$ Process array$2$

int $*$ array$2=$ new int$[$size$2]$;

cout $<<$ "array$2$:

$"$;

for $($int i $=0$; i $<$ size$2$; i$++)$

$\{$

array$2[$i$]=42$;

cout $<<$ array$2[$i$]<<""$;

$\}$

cout $<<$ endl;

$//$ Location B

$//$ Location C

return $0$ ;

$\}$

Step $1$: Copy this program into your C$++$ program editor, and compile it$.$ Hopefully you will not get any error messages. Run the program with a variety of input values to see what it prints. You should see a lot of $17\text{'}$s and $42\text{'}$s printed on the screen.

Step $2$: It is very important to return memory to the operating system when you are finished working with it$.$ Otherwise, your program will have a "memory leak" and it may die if it runs out of memory. Edit your program and add the following code at "Location A$"$ in the program.

$//$ Return memory to O$/$S

delete $[]$ array$1$;

Step $3$: Compile and run your program. It should print out the same information as before. Since we are releasing the memory for array$1$ before we are allocating array$2$ there is some chance that the O$/$S will reuse some or all of array$1$ memory for array$2.$ To see if this is true, you can edit the body of the array$2$ print loop as follows:

cout $<<$ array$2[$i$]<<""$;

array$2[$i$]=42$;

Step $4$: Recompile and run your program with size$1=20,$ size$2=40.$ Then try size$1=20,$ size$2=20.$ Finally try size$1=40,$ size$2=20.$ You should see that in some cases the initial values of array$2$ are equal to zero, and in other cases they are equal to the values we stored in array$1,$ proving the memory has been reused.

Step $5$: In step $2$ we returned the array$1$ memory back to the O$/$S$.$ Since we have not changed this pointer, it still points to the original chunk of memory we allocated at the top of the program. For this reason, array$1$ is called a dangling reference $--$ it points to memory that was valid at one time, but the O$/$S thinks this pointer is no longer in use. To see what is now in in array$1,$ add the following code at "Location B$"$ in the program.

$//$ Print array$1$

cout $<<$ "array$1$:

$"$;

for $($int i $=0$; i $<$ size$1$; i$++)$

cout $<<$ array$1[$i$]<<""$;

cout $<<$ endl;

Step $6$: Recompile and run your prog