Class 09: Memory Management

Held Friday, February 11, 2000

Overview

Today, we conclude our study of C by visiting some further issues of memory management.

Notes

• Because I have not yet returned assignment 1, I'm extending the due date for assignment 2 until Wednesday.
• I expect to return assignment 1 on Monday.

Contents

• Pointers and Arrays
• Allocation and Deallocation
• Dangers
• Pointer Lab
  • Allocation with arrays
  • Aliasing

Summary

• Pointers and arrays
• Allocation and deallocation
• Experiments: allocation, deallocation, and aliasing

Pointers and Arrays

• In C, pointers and arrays are essentially equivalent; they're just two notations for the same concept.
• If you declare ip as a pointer to an integer, ip[0] is the memory location associated with ip.
  • Similarly, ip[1] is the next memory location!
• If you declare iarr as an array of integers, *iarr gives the 0th element of the array and iarr++ chops off the first element.
• Arrays differ from pointers in that you can predeclare the memory for an array, as in the following.

  int iarr[10];
  

  • You don't have to free this memory! C will do so when your method terminates.
  • You also shouldn't use this memory after the method terminates.

Allocation and Deallocation

• As you've seen in our examples, in C you can allocate new memory with malloc.
• malloc is declared in stdlib.h, which you should include.
• It takes an integer (okay, a size_t) as a parameter. That's the number of bytes to allocate.
• It returns a generic pointer (of type void *).
  • You'll need to cast it to the appropriate type.
• It may allocate more memory than you've asked for.
• It may allocate no memory, so you should always check the return value.
• C won't clean up after your program, so you are responsible for deallocating any memory you allocate and no longer need. You can deallocate memory with free.
• Programs that deallocate memory that still has references to it are likely to behave incorrectly.
• Programs that never deallocate memory are likely to run out of memory.

Dangers

• Nothing stops you from accessing (or going beyond) legal areas of memory. Such accesses will most likely screw up your program.

Pointer Lab

Allocation with arrays

Consider the following program:

#include <stdio.h>

int *stuff;

/* "Allocate" space for stuff. */
void setupStuff()
{
  int junk[10];
  int i;
  stuff = junk;
  for (i = 0; i < 10; i++)
    stuff[i] = i;
} /* setupStuff() */

/* Print some values */
void printVals()
{
  int i,j,k;
  j = 100;
  k = 200;
  for (i = 0; i < 10; i++)
    printf("stuff[%d]: %d\n", i, stuff[i]);
  printf("i: %d\n", i);
  printf("j: %d\n", j);
  printf("k: %d\n", k);
} /* printVals() */

main()
{  
  setupStuff();
  printVals();
} /* main() */

• What do you expect the output to be?
• Compile the program with gcc and then run it.
  • What output do you get?
  • How do you explain the output?
• Compile the program with gcc -O and then run it.
  • What output do you get?
  • Read the man page for gcc to determine what -O does.
  • How do you explain the differences?
• Compile the program with cc and then run it.
  • What output do you get?
  • How do you explain the output?
• Compile the program with c89 and then run it.
  • What output do you get?
  • How do you explain the output?
• Rewrite the program so that printVals recurses five times. Compile with c89 and execute.
  • How do you explain the output?
• Rewrite the program so that stuff is initialized as follows:

    stuff = (int *) malloc(10*sizeof(int));
  

• Compile with the various compilers and see what effect this has.

Aliasing

Consider the following program:

#include <stdio.h>
#include <stdlib.h>

#define ENTRIES 5

main()
{
  int i;
  int *A;
  int *B;
  int *C;
  A = (int *) malloc(ENTRIES * sizeof(int));
  B = A;
  C = (int *) malloc(ENTRIES * sizeof(int));
  for (i = 0; i < ENTRIES; i++) {
    A[i] = i;
    C[i] = i;
  }
  for (i = 0; i < ENTRIES; i++)
    printf("B[%d]: %d; ", i, B[i]);
  printf("\n");
  for (i = 0; i < ENTRIES; i++)
    printf("C[%d]: %d; ", i, C[i]);
  printf("\n");
  free(A);
  A = malloc((ENTRIES-1) * sizeof(int));
  for (i = 0; i < ENTRIES-1; i++)
    A[i] = 9*i;
  for (i = 0; i < ENTRIES; i++) 
    printf("B[%d]: %d; ", i, B[i]);
  printf("\n");
  for (i = 0; i < ENTRIES; i++) 
    printf("C[%d]: %d; ", i, C[i]);
  printf("\n");
} 

• What do you expect the output to be?
• Compile the program with gcc and then run it.
  • What output do you get?
  • How do you explain the output?
• Do you get different output with other compilers or optimization on?
  • If not, why not?