Question

Introduction:

One of the most important uses of pointers is for dynamic allocation of memory. In C++ there are commands that let the user request a chunk of memory from the operating system, and use this memory to store data. There are also commands to return memory back to the O/S when the program is finished using the data. In this lab, we will explore some of the things that can go wrong when using dynamic memory and discuss how to avoid these problems.

As you saw in the previous lab, we there are five steps we must follow when using dynamic variables:

• Declare a pointer variable of the desired data type
• Use the "new" command to request memory
• Make use of the memory in the program
• Use the "delete" command to return memory
• Set the pointer variable to NULL

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 <cstdlib>
#include <iostream>
using namespace std;

// Main function
int main()
{
   // Get user input
   int size1 = 0;
   cout << "Enter size of array1:\n";
   cin >> size1;
   if (size1 < 0) 
      size1 = 0;

   // Get user input
   int size2 = 0;
   cout << "Enter size of array2:\n";
   cin >> size2;
   if (size2 < 0) 
      size2 = 0;

   // Process array1
   int * array1 = new int[size1];
   cout << "array1:\n";
   for (int i = 0; i < size1; i++)
   {
      array1[i] = 17;
      cout << array1[i] << " ";
   }
   cout << endl;

   // Location A

   // Process array2
   int * array2 = new int[size2];
   cout << "array2:\n";
   for (int i = 0; i < size2; i++)
   {
      array2[i] = 42;
      cout << array2[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's and 42'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 [] array1;

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

      cout << array2[i] << " ";
      array2[i] = 42;

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

Step 5: In step 2 we returned the array1 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, array1 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 array1, add the following code at "Location B" in the program.

   // Print array1
   cout << "array1:\n";
   for (int i = 0; i < size1; i++)
      cout << array1[i] << " ";
   cout << endl;

Step 6: Recompile and run your program with size1=20, size2=40. Then try size1=20, size2=20. Finally try size1=40, size2=20. You should see that in some cases the initial values of array1 are unchanged, and in other cases they are equal to the values we stored in array2. In practice it is a very bad idea to use dangling references, because the odds are high that the original data will be changed.

Step 7: It is considered the be a "good programming practice" to set the pointer variable to NULL after you return the dynamic memory. This will prevent programmers from accidentally using a dangling reference later in the program. To see how this works, add the following code at "Location C" in the program.

   // Print array1
   array1 = NULL;
   cout << "array1:\n";
   for (int i = 0; i < size1; i++)
      cout << array1[i] << " ";
   cout << endl;

Step 8: Recompile and run your program with size1=20, size2=20. What does your program output now? You should see "Segmentation fault (core dumped)" which is one of the oldest run time error messages. You will see this message whenever you attempt to access memory using a pointer that is equal to NULL. In this case, the error occurs when we attempt to use array1[i] inside the for loop. Debugging run time errors like this can be a pain sometimes, but they are almost always easier to find than subtle run time errors caused by incorrectly using dangling references. To fix this code, remove all of the code you added in Step 7 except the "array1 = NULL;" line.

Step 9: Edit your program one last time, and add the following code just before the return statement. This is the preferred method for returning memory to the O/S and preventing dangling references in C++. In future, you should use this pair of lines together when you release dynamic memory.

   // Return memory to O/S
   delete [] array2;
   array2 = NULL;

Step 9: Compile your program one last time, and upload your code into the auto grader by following the instructions below.

Answer 1

If you have any doubts, please give me comment...

// Include statements

#include <cstdlib>

#include <iostream>

using namespace std;

// Main function

int main()

{

// Get user input

int size1 = 0;

cout << "Enter size of array1:\n";

cin >> size1;

if (size1 < 0)

size1 = 0;

// Get user input

int size2 = 0;

cout << "Enter size of array2:\n";

cin >> size2;

if (size2 < 0)

size2 = 0;

// Process array1

int *array1 = new int[size1];

cout << "array1:\n";

for (int i = 0; i < size1; i++)

{

array1[i] = 17;

cout << array1[i] << " ";

}

cout << endl;

// Location A

// Return memory to O/S

delete[] array1;

// Process array2

int *array2 = new int[size2];

cout << "array2:\n";

for (int i = 0; i < size2; i++)

{

array2[i] = 42;

cout << array2[i] << " ";

}

cout << endl;

// Location B

// Print array1

cout << "array1:\n";

for (int i = 0; i < size1; i++)

cout << array1[i] << " ";

cout << endl;

// Location C

// Print array1

array1 = NULL;

cout << "array1:\n";

for (int i = 0; i < size1; i++)

cout << array1[i] << " ";

cout << endl;

// Return memory to O/S

delete[] array2;

array2 = NULL;

return 0;

}