CMPT 212 Object-Oriented Applications Design in C++ Fall 1997

Read section "Pointers and Free Store" (pages 117-144) in chapter 4 from C++ Primer Plus (2nd ed.), by Stephen Prata.

Pointers and const

• By combining the const type modifier and the * type modifier, we can get different kinds of pointers.
  • Pointer to a constant: we cannot change the value pointed to.
    

       int x = 3;
       int w = 4;
       const int * y;    // y is a pointer to a "const int".
       y = &x;
       *y = 7;           // error: y is pointing to a constant, and
    		     //        we cannot change a constant.
       y = &w;
       w = 5;
    	       

  • Constant pointer: we cannot change the pointer.
    

       int x = 3;
       int w = 4;
       int * const y = &x;    // constants must be initialized.
       *y = 5;  
       x = 6;
       y = &w;                // error: y is a constant, and we
    			  //        cannot change a constant.
    	       

  • Constant pointer to a constant: we cannot change the pointer or the value pointed to.
    

       int x = 3;
       int w = 4;
       const int * const y = &x;   // constants must be initialized.
       x = 5;
       *y = 6;                     // error: y is pointing to a constant.
       y = &w;                     // error: y is a constant.
       w = 7;
    	       

• When to use const with pointers:
  1. If the item pointed to will not change, make the pointer point to a const.

        const int * p;
     	       

  2. if the pointer will always point to the same item, make the pointer a const.

        int * const p = ...;
     	       

  3. If both apply, use const for both.

        const int * const p = ...;
     	       

Dynamic Memory Operations

• Often the amount of data a program will be working with is not known until the program is run. That is, it depends on the input.

• To deal with this situation, we must be able to allocate more memory as we need it and release it when we no longer need it.

• C++ provides two dynamic memory operators:
  
  • new allocates memory.
  • delete releases memory.

• Some languages (such as Java, Eiffel, Smalltalk, Modula-2, 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.

Return to lecture notes index

Lectures