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

Constants

• C++ provides the keyword const which is a type modifier.

• A variable defined with const cannot have its value changed. It must therefore be initialized when it is defined.
  • Example:
    

       const float pi = 3.0;
       pi = 3.14159;         // causes a compiling error.
                   

• Parameters can also be defined as const. This means that the function promises not to change the value of the parameter.
  • Example:

       void f(const int x) {
          x = 7;               // error.
       }
    
       void g(const bigStruct& w) {
          w = ...;            // error.
       } 
    	       

    In function g, w is passed by reference for efficiency, but is defined with const to guarantee that w will not be changed in g.

• Use const wherever you can in your code. Then the compiler can catch those places where you accidentally change values.

Pointers and Addresses

• Do not confuse pointers with address!

• An address is the number of a memory location. A pointer is a memory location which holds an address.
  • Example:

       int x = 8;
       int * y;
       y = &x;
       cout << x;       // outputs 8.
       cout << y;       // outputs 11.
       cout << &x;      // outputs 11.
       cout << &y;      // outputs 14.
       cout << &(&x);   // error: &x has no address.
       cout << &(&y);   // error: &y has no address.
                   

    
  • The difference between &x and y is the same as the difference between 3 and int.

• Like the symbol &, the symbol * has more than one meaning, and these meanings are often confused.
  • * can be a type modifier.

       int * y;    // y is a pointer to an int.
    	       

  • * is also an operator: the dereference operator.

       int w;
       w = *y;   // *y is the int that y points to. 
    	       

  • Example:

       int x;
       int * y;
       y = &x;
       *y = 3;          // x also becomes 3.
       cout << x;       // outputs 3.
       x = 4;
       cout << (*y);    // outputs 4.
    	       

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.

Return to lecture notes index

Lectures