Memory

• static: global variable storage, permanent for the entire run of the program.
• stack: local variable storage (automatic, continuous memory).
• heap: dynamic storage (large pool of memory, not allocated in contiguous order).

By convention, we express these addresses in base 16 numbers. For instance, the smallest possible address is 0x00000000 (where the 0x means base 16), and the largest possible address could be 0xFFFFFFFF.

• Static memory

  persists throughout the entire life of the program, and is used to store things like global variables, or variables created with the static clause. For example:

  int theforce;

  The memory to store this variable can come from one of two places:

  • If a variable is declared outside of a function, it is considered global (i.e. accessible anywhere in the program). Global variables are static, and only one copy for the entire program exists.
  • In a function the variable is allocated on the stack. You can force a variable to be static with the static clause. For example, the same variable that was declared inside a function with the static clause would allow it to be stored in static memory.

    static int theforce;

• Stack memory

  The stack segment is near the top of memory with high address. Every time a function is called, the machine allocates some stack memory for it. When a new local variables is declared, more stack memory is allocated for that function to store the variable. Such allocations make the stack grow downwards. After the function returns, the stack memory of this function is deallocated, which means all local variables become invalid. The allocation and deallocation for stack memory is automatically done.

  • The stack store variables that are declared inside a function (including the main() function). The stack is organized as a LIFO structure, (i.e. 'Last-In-First-Out').
  • Every time a function declares a new variable it is 'pushed' onto the stack. The stack segment is near the top of memory with high address. Such allocations make the stack grow downwards.
  • When a function finished, all the function variables on the stack are deleted, and memory is freed up (i.e. 'local' scope of function variables). Since the stack memory of a function gets deallocated after the function returns, there is no guarantee that the value stored in those area will stay the same.
  • A common mistake is to return a pointer to a stack variable in a helper function. After the caller gets this pointer, the invalid stack memory can be overwritten at anytime.
  • The stack is a special region of memory and automatically managed by the CPU (i.e. the programmer does not have to allocate or deallocate memory). In particular, stack memory is chopped into successive frames where each time a function is called, it allocates itself a fresh stack frame.

  

  Example: Different variables are put on the stack as a function of their occurrence in main and subfunctions.

  There is a limit on the size of the stack which can vary with the operating system (e.g. OSX currently has a default stack size of 8MB). If a program puts too much information on the stack, the stack overflows. Stack overflow happens when all the memory in the stack has been allocated. Further allocations begin overflowing into other sections of memory.

  A summary of the stack:

  • the stack is managed by the CPU, there is no ability to modify it
  • variables are allocated and freed automatically
  • the stack it not limitless - most have an upper bound
  • the stack grows and shrinks as variables are created and destroyed
  • stack variables only exist while the function that created them still exists

  Pirate techniques on the stack:

• Heap memory

  The heap is a large pool of memory that can be used dynamically (i.e. 'free storage'). This is memory that is not automatically managed; the programmer has to explicitly allocate (using functions such as malloc), and deallocate (e.g. free) the memory. Unlike the stack, there are generally no restrictions on the size of the heap, other than the physical size of memory in the machine. Variables created on the heap are accessible anywhere in the program. Most importantly, heap memory requires the programmers to use pointers!.

  A summary of the heap:

  • the heap is managed by the programmer, the ability to modify it is somewhat boundless
  • in C, variables are allocated and freed using functions like malloc and free
  • the heap is large, and is usually limited by the physical memory available
  • the heap requires pointers to access it

  Check out the Example code here

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

  int x;
  

  int main(void){ 
       int y;   
       char *str; 
  
       y = 4;
       printf("stack memory: %d\n", y);
       
       str = malloc(100*sizeof(char)); 
       str[0] = 'm';
       printf("heap memory: %c\n", str[0]); 
       
       free(str);         
       return 0;
       }
  
  

  The variable x is static storage, because of its global nature. Both y and str are dynamic stack storage which is deallocated when the program ends. The function malloc is used to allocate 100 pieces of of dynamic heap storage, each the size of char, to str. Conversely, the function free, deallocates the memory associated with str.

  

  ---