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

The bool Type

• C and early C++ had no boolean type. Conditional expressions expected integers, and interpreted zero as false and any other value as true.

• C++ now has a bool type with values true and false.

• Borland C++ 5.0 has the bool type. Earlier versions do not. Similarly, older versions of Microsoft C++ may not have it.

• To make your program compile with compilers that do not have the bool type, you can define bool yourself.
  • Example:

       // bool.h
       #ifndef _bool_h_
       #define _bool_h_
    
       #if (__BORLANDC__ < 0x500)
          enum bool { false, true };
       #endif
    
       #endif
    	       

    The value __BORLANDC__ is set by the Borland system header files to be equal to the compiler's version number. This example may have to be adjusted to work with Microsoft's compilers. (Note that there are two underscores before and after BORLANDC.)

Reference Types

• A variable or parameter can be made into a reference variable or parameter by adding a type modifer & to the end of its type.
  • Example:

       int x = 3;      // x is an integer.
       int& y = x;     // y is a reference to an integer.
    	       

• A reference is another name for some item.
  In the example above, the names x and y both refer to the same memory location which holds the integer 3.
• A reference variable must be initialized when it is defined.
  • Example:

       int& y;      // causes a compiling error.
    	       

  • Think of the definition

       int& y = x;
    	       

    as meaning "y is another name for x".

• 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.

Return to lecture notes index

Lectures