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

Function Overloading (continued)

• Functions of the same name are distinguished by the number of parameters and types of parameters. Note that parameter names are irrelevant.

• Examples:

     // file display.h
     void display(char c);          // first display function.
     void display(int i);           // second display function.
     bool display(char c, int i);   // third display function.
  
     // file one.cpp
     ...
     char letter;
     int  width;
     bool result;
     ...
     display(letter);                  // calls first display function.
     result = display(letter, width);  // calls third display function.
     display(width);                   // calls second display function.
  	 

• You cannot have two functions with the same name and same parameters but which have different return types.
  • Example:

       void display(char c, int i);
       bool display(char c, int i);    // causes a compiling error.
    	       

• When you call an overloaded function with actual parameters that do not exactly match any of the formal parameters, the compiler will try to convert the actual parameters to another type in order to match some function definition.
  • If it cannot get a match or if there is more than one possible match, then an error results.

  • Example: unique match.

       void display(float f);
       void display(bool b);
       ...
       int i;
       ...
       display(i);          // calls display(float).
    	       

  • Example: no match.

       void display(float f);
       void display(bool b);
       ...
       char c; 
       ...
       display(c);          // causes a compiling error.
    	       

  • Example: ambiguous match.

       void display(long x);
       void display(int i);
       ...
       unsigned int i;
       ...
       display(i);          // causes a compiling error.
    	       

Function Default Parameters

• Default parameters are parameters which have default values that are used if actual parameters are not given when the function is called.

• Only the latter part of the parameter list can be defaulted.

• It is an error to omit parameters when calling a function if those parameters have not been defaulted.

• Example:

     void display(char c, int size = 12, int x = 0, int y = 0);
     ...
     display('W');              // same as display('W', 12, 0, 0).
     display('W', 5);
     display('W', 5, 16, 10);
     display();                 // causes a compiling error.
  	 

• Using default parameters in your program can easily lead to confusion. You should use them carefully and only when they will make your program easier to understand.

• Make sure you understand the difference between calling a function with default parameters and calling various forms of an overloaded function.

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

Return to lecture notes index

Lectures