CMPT 212 Object-Oriented Applications Design in C++ Spring 1998

Dynamic Memory Operations (continued)

• Some languages (such as Java, Eiffel, Smalltalk, Modula-3, Haskell, and ML) have automatic garbage collection. In these languages, the programmer does not have to release memory. The run-time system of the language will automatically release a piece of memory when that piece is no longer used by the program.
  • Automatic garbage collection has two benefits:
    
    1. The programmer cannot accidentally dereference a pointer that points to memory that has already been released.
    2. The programmer does not have to ensure that all allocated memory is eventually released. Failure to do so can cause a memory leak.

• The new operator takes one parameter (a data type) and returns an address.
  • The address is the address of a piece of memory big enough to hold a value of the given type.

  • Example:

       int  * pInt = new int;
       char * pChar = NULL;
       pChar = new char;
    	       

  • If the new operator cannot allocate the memory needed, it throws an exception. We will cover exceptions later.

• The delete operator takes one parameter (a pointer) and releases the piece of memory pointed to by that pointer.
  • Example:

       delete pInt;
       pInt = NULL;
       delete pChar;
       pChar = NULL;
    		

  • delete knows how much memory to release because the pointer is defined to point to a certain type.

  • If the pointer is NULL, delete does nothing.

  • It is a good idea to always set a pointer to NULL after delete-ing it.

• We can also allocate and release arrays with new and delete.
  • Example:

       float * pArray = new float[10];
       ...
       delete [] pArray;
    	       

Scope and Lifetime

• Lifetime is the time during execution where an item exists.

• Scope is the range of statements in a program where an item can be used.

• Note that during the execution of the program, an item may exist but not be accessible.

• The lifetime of an item can be automatic, dynamic, static duration, or persistent.
  • Automatic items are defined within a function or block and exist only during that function or block.
    • Example:

         void f(char c) {
            float g = 3.0;
            for (int i = 0; i < 10; i++) {
      	 int j;
      	 j = i;
      	 cout << j;
      	 }
            cout << g;
            return;
         }
      	            

      g exists for the entire function, and i and j exist only in the loop.

  • Dynamic items are allocated by a dynamic memory allocation and can exist longer than the duration of the function in which they were allocated. They exist until they are released.

  • Static duration items exist for the entire duration of the program.
    • Example:

         void f(int x) {
            static int count = 0;
            count++;
            cout << "f has been called " << count << " times.";
            ...
            return;
         }
      	            

      count exists for the duration of the program, although its scope is just the function f.

  • Persistent items exist longer than the duration of the program. These items must be stored in non-volatile storage (such as a disk).

Return to lecture notes index

Lectures