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

	Read chapter 8 (except for the sections on function templates and function template overloading) from C++ Primer Plus (2nd ed.), by Stephen Prata.
	If you haven't used C or C++ for a while, you might want to read chapter 7 as a review.

Separate Compilation

• Separate compilation is where we divide the source code of a program into separate files and compile these files separately.
  • Each source file produces an object file.

  • The object files are combined into an executable file by a linker.

  • The object files and the executable files contain machine code which the computer can execute.

  • The source files contain the source code which people can understand.

  • Note that a program can have different parts written in different programming languages.

• This diagram shows how the source files are compiled to produce the objects files, which are then linked to produce the executable file.

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

Return to lecture notes index

Lectures