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

Function Prototypes

• Problem: When function X calls function Y, how can we ensure that X is passing the correct number of parameters, using the correct parameter types, and expecting the correct return value type?
  • Note that this problem can occur even if X and Y are in the same source file.

• One solution: Have the compiler go through the source code and determine all the parameters that functions are expecting, then go through the code a second time and make sure that the functions are being called correctly.
  • This is a two-pass compiler.
  • This makes the compiler slower.
  • How do we handle different source files?

• Another solution: Force the programmer to declare the number of parameters, the parameter types, and the return value type of a function before that function is called ("before" means appearing ahead of it in the source code).
  • Note that we are not defining the function (writing the body of the function). We are only giving the function's signature. This is called a function declaration or a function prototype.

• Examples:
  • If the function is defined before it is called, there is no problem.

       int times10(int x) {          //
          return x*10;               //  function definition.
       }                             //
                   
       int main() { 
          int number; 
          cin >> number; 
          cout << times10(number);   //  function is called here.
          return 0; 
       }
                    

  • If the function is not defined before it is called, a function prototype must apprear before the place where it is called.

      int times10(int);               //  function prototype
                                      //  (function declaration).
    
      int main() { 
          int number; 
          cin >> number; 
          cout << times10(number);    //  function is called here.
          return 0; 
       }
    
       int times10(int x) {           //
          return x*10;                //  function definition.
       }                              //
                    

• Why do function prototypes solve the problem?
  • The compiler can check that
    1. the prototype matches the way the function is called,
    2. the prototype matches the way the function is defined.

  • By the law of transitivity, if 1 and 2 are true, then the way the function is called must match the way it is defined.

  • Note that this solution will work even if the compiler only does one pass through the source code.

• Remarks about function prototypes:
  • The parameter names can be given, but the compiler ignores them. If they are given, it is for the benefit of the programmer, not the compiler.

  • A function can be declared many times, but it can only be defined once.

  • A function definition causes the compiler to generate object code for that function, but the compiler does not do that for function declarations.

Header Files

• Problem: How can we use function prototypes if the calling function and the called function are in different source files?

• We must ensure that the compiler sees the same prototype when it compiles each of these two source files. Otherwise the law of transitivity will not hold.

• Our solution: Put the function prototype in a third source file, and have the compiler include it in each of the two source files when it compiles them.
  • This third file is called a header file.

  • Header files are never compiled by themselves. They are only used for including into other source files.

Return to lecture notes index

Lectures