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

The following sections of Prata should be a review: Chapter 3. Chapter 4, except the section Pointers and Free Store. Chapter 5, except that the sections on cin.get() may be new. Chapter 6.

Header Files (continued)

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

• When we build a program, we compile every source file then link the object files together to produce an executable file.
  • In the example above, we would compile one.cpp, two.cpp, and three.cpp, then link one.obj, two.obj, and three.obj to produce program.exe.

• When we make a program, we only compile the source files which have changed or which depend on files which have changed. If any object files have changed (either before the make or during the make), we link the object files to produce the executable file.
  • In the example above, if we changed two.cpp and then did a make, we would compile two.cpp then link one.obj, two.obj, and three.obj to produce program.exe.

  • If we changed three.h, we would compile two.cpp and three.cpp then link all of the object files.

  • If we changed two.obj, we would just link all the object files.

• Question: how do we tell if a file has been changed?
  • Normally we use the "last changed" time stamp of the file.

  • If file X depends on file Y and the time stamp of Y is later than the time stamp of X, then we assume that X must be reprocessed.

Return to lecture notes index

Lectures