Build: Start

Build: Compile main.cpp

Build: Compile utility.cpp

Build: Link

Separate Compilation

• Real programs are composed of multiple files
• Files are compiled separately into object files
• The object files are linked together using the linker
• For each application, one file is the main program and contains the main function
• Separating functions and classes into separate files increases cohesion (good) but also increases coupling (can be bad)

File Structure

Include File

• Required header comment, as in any other source file
• Required include guard to prevent the compiler from seeing these contents more than once
• Insert only the include of any files needed for the function declarations
• Insert the function declarations (function prototypes)
• The code that uses the include file must compile no matter where it is included or which includes precede it

Include Guard Macro Names

• Generate the name based on the name of the file: All uppercase, and replace dot '.' with an underscore '_'
• May include a standard prefix (separated by an underscore). I use the prefix INCLUDED_ (see [Lakos])
• If there are underscores in the name, use them. Do not add underscores for anything else

Implementation File

• Required header comment, as in any other source file
• Include the related include file first, then when you compile the implementation file, you check that the include file is complete.
• Insert any included files needed for the implementation
• An include file is needed in the implementation file if it is used in the implementation of the code, i.e., the function definition
• Do not include .cpp files
• In this class including a .cpp file leads to a 0 on the exercise or project

Roles

Design Guideline

Hide as many concerns as possible in the implementation file

• The only include files in the include file should be those needed for the interface
• This means the include files needed for code that calls the functions provide by the interface
• Include files used only in the implementation belong in the implementation file

Indirect Includes

Direct Includes

Self-Sufficiency

• An include file needs to be self-sufficient
• It should not depend on previous includes or the order of includes
• This applies to all include files that we write

IWYU

• Include What You Use
• In every .cpp or .hpp, include any needed include files
• Do not depend on indirect includes
• This allows implementers of the include files to change their dependencies

Exposing Implementation Concerns

Hiding Implementation Concerns

Summary

• The include file, e.g., Aggregate.hpp, is for the callers of a function
• Want to make it as easy as possible for the callers, so only include what is needed for the caller of the function
• Every include file is a dependency. The fewer dependencies, the better.
• Keep as many details hidden in the implementation file, e.g., Aggregate.cpp