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

Separate Compilation (continued)

• Advantages of separate compilation:
  1. Parts of the program can be written in different languages.

  2. If changes are made to the program, we only need to recompile the source files which contain the changes, not the whole program.

  3. Different programmers can be working on different parts of the program at the same time.

  4. It is easier to write commonly used modules and use them in different programs.

• Disadvantages and difficulties of separate compilation:
  1. Difficulty in deciding how to split up the program into modules.

  2. If a subroutine X in one source file calls a subroutine Y contained in another source file, how do we ensure that
     1. Y exists,
     2. X is calling Y with the correct number of parameters,
     3. X is calling Y with the correct parameter types,
     4. X is expecting the correct type of value returned by Y.

  3. If a subroutine X in one source file uses a variable Y contained in another source file, how do we ensure that
     1. Y exists,
     2. X knows the correct type of Y.

  4. How do we prevent the same subroutine or variable from being defined in different source files? Or should we prevent this?

  5. How can a subroutine in one source file call a subroutine in another source file if they are written in different programming languages?

• Addressing these difficulties:
  • Difficulty #1: how to split up the program.
    • This is a design decision, not a coding decision. It should be independent of the programming language being used and should reflect the solution of the problem being solved.

  • Difficulties #2 and #3: using "external references".
    • In C++, we will use header files to solve this problem. More on this later.

  • Difficulty #4: multiple definitions.
    • The linker should report these as errors or warnings.

  • Difficultes #5: different programming languages.
    • Not covered in this course.

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

Return to lecture notes index

Lectures