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

Reference Types (continued)

• Reference variables are rarely needed, and can lead to subtle bugs and code which is difficult to understand.

• Do not confuse the reference type modifier & with the address-of operator &.
  • The address-of operator & is an operator that takes one parameter and returns the address of that parameter.
    • Example: &x is the address of x.

  • The reference type modifier & is part of the type definition of an item.

Reference Parameters

• Reference parameters, unlike reference variables, can make a program easier to understand and can help reduce the number of subtle bugs.

• The two most common ways of passing parameters to a function are by value and by reference.

• When a parameter is passed by value, the function gets its own copy of the parameter value. If the function makes changes to its copy of the parameter, the original parameter is unchanged.
  • Example:
    

       void f(int x) {
          x = 4;
          return;
       }
    
       int main() {
          int y = 3;
          f(y);
          return 0;
       }
    	       

    Inside function f, we cannot access y. We can only access a copy of y, which is called x.

• When a parameter is passed by reference, the function has access to the actual parameter that was passed. If the function makes changes to the parameter, the original parameter is changed, since the function is accessing the original parameter.
  • Example:
    

       void f(int& x) {
          x = 4;
          return;
       }
    
       int main() {
          int y = 3;
          f(y);
          return 0;
       }
    	       

    The names y and x refer to the same item.

• C only has pass-by-value. It does not have pass-by-reference, although pass-by-reference is simulated by passing pointers by value.

• With the introduction of references, C++ now has pass-by-reference.

• There are two reasons why we use pass-by-reference:
  1. We want the function to be able to change the value of a parameter.
  2. It the parameter is a large item (such as a struct), passing by reference is much faster.

• When you comment the parameters of a function, be sure to state whether the value of a parameter is going into a function, coming out of the function, or both.

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.
    	       

Return to lecture notes index

Lectures