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

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.

• Example: using our previous example, assume main and time10 are in different source files.

     // file multiply.cpp
  
     #include "multiply.h"
  
     int times10(int x) {          //
        return x*10;               //  function definition.
     }                             //
  
  
     // file main.cpp
  
     #include "multiply.h"
  
     int main() {
        int number;
        cin >> number;
        cout << times10(number);   //  function is called here.
        return 0;
     }
  
  
     // file multiply.h
  
     int times10(int x);           //  function prototype.
  
           

• Remarks about #include.
  • The #include preprocessor directive causes the contents of the named file to be temporarily placed into the source file at the location of the #include during the compiling process.

  • If the named file is enclosed in < >, the preprocessor looks for the file in the standard system header file directory. If it is enclosed in " ", the preprocessor looks for the file in the current directory first, then in the system directory. (System header files should be enclosed in < > and your header files should be enclosed in " ".)

• If a function X in source file A.cpp is meant to be called from functions not in A.cpp, then a prototype for X should be put in the header file A.h corresponding to A.cpp.
  A.h should be included by A.cpp and by any source file that contains functions which call X.
  • Any function in A.cpp which is not meant to be called from outside A.cpp should be declared static and should not have a prototype in A.h. Its prototype should appear in A.cpp.

  • A.h should be an "advertisement" of those functions which may be called by other modules.

• Example:

     // file multiply.cpp
  
     #include "multiply.h"
  
     static int times2(int x);      //  function prototype.
  
     int times10(int x) {           //
        return x*10;                //  function definition.
     }                              //
  
     int times8(int x) {            //
        return 4*times2(x);         //  function definition.
     }                              //  
  
     static int times2(int x) {     //
        return x+x;                 //  function definition.
     }                              //
  
  
     // file multiply.h
  
     int times10(int x);            //  function prototype.
     int times8(int x):             //  function prototype.
  
  
     // file main.cpp
  
     #include "multiply.h"
  
     int main() {
        int number;
        cin >> number;
        cout << times10(number);
        cout << times8(number);
        cout << times2(number);     //  causes a compiling error.
        return 0;
     }
           

Dependencies

• A file A is dependent on another file B if changes in B should cause changes in A.
  • A source file X.cpp is dependent on a header file Y.h if X.cpp includes Y.h.

  • An object file X.obj is dependent on a source file Y.cpp if X.obj is produced by compiling Y.cpp.

  • An executable file X.exe is dependent on an object file Y.obj if Y.obj is one of the object files linked to produce X.exe.

• Dependencies are transitive. If X is dependent on Y and Y is dependent on Z, then X is dependent on Z.

• Example: In this diagram, every arrow represents a dependency. There are also dependencies which are not shown, but which can be derived. For example, program.exe depends on one.h.

Return to lecture notes index

Lectures