Static vs. Dynamic Memory Allocation

Static Memory Allocation

• Memory is allocated at compile time. (sort of)
• Have to know how much memory is needed at compile time.
• Example:

      double myArray[5] = { 3, 6, 9, 12, 15 };
      LabelEntry  staticEntries[5];
      staticEntries[2].label = "Label1";
  

• The "lifetime" of static memory is related to its scope. Local variables have use of specific memory for the duration of their function (or block). After that, the memory can be reused. Global variables have memory set aside for entire program.

Dynamic Memory Allocation

• Memory is allocated at run time.
• Might not know how much memory is needed until you need it.
• malloc: standard library function for memory allocation (#include <stdlib.h>);
  malloc returns the address of the memory it just set aside.
• (Note: Java object construction is dynamic: new Fish(color, loc);)
• Example:

      int i;
      double * memoryBlock = malloc(5*sizeof(double));
      double * ptr = memoryBlock;
      for ( i = 3; i <= 15; i += 3, ptr++ )
          *ptr = i;
      LabelEntry  * staticEntries = malloc(5*sizeof(LabelEntry));
      staticEntries[2].label = "Label1";
         /* We can use array indexing with a pointer.  We could also use:
              (staticEntries + 2)->label = "Label1";      or
              *(staticEntries + 2).label = "Label1";
         */
  

• Memory that has been allocated dynamically outlasts the function or block in which it was created. It remains allocated until you explicitly free the space, which then makes it available for other uses in your program.

      free(memoryBlock);
  

  The pointer to the space might be static, though, in which case you may lose the pointer without freeing the memory (memory is still allocated but unreachable). This is called a memory leak, because over time you will have a shrinking pool of available memory.