Modular Compilation

• This is from chapter 12.3, if you want a reference.
• But it fits very nicely here with this topic too.
• Justification
  • Sometimes you wish to make a "library" of functions
  • Or even separate out a data type, like we have just created.
  • Sometimes we do this just to organize our code.
• What does the pre-processor do
• What are include files?
  • These are sometimes called specification files
• What does the linker do?
• Building a specification file
  • called filename.h
  • Should begin with

    #ifndef SOME_UNIQUE_NAME
    #define SOME_UNIQUE_NAME
    
    Your Code Goes Here
    #endif
    	 

  • Should include
    • type declarations you want exported to other routines
    • constant declarations you want exported to other routines
    • function prototypes you want exported to other routines
    • #include statements needed
  • Should not include (except under unique conditions)
    • variables
    • executable code
    • using namespace std;
      use std:: in place of this, more on this in 330
      • #include not needed
    • An example: calType.h
  • The implementation file
    • This is a .C file.
    • #include "filename.h"
    • Implement the code for the prototypes
    • An example: calType.C
  • The routine that uses the library
    • #include "filename.h"
    • Use the constants, types, and routines as normal
    • An Example : myCal.C
  • To compile
    • Compile the library into an object file (not executable)
    • g++ -c -o filename.o filename.C
      • -c says to make an object file, but do not link
    • g++ -o main main.C filename.o
      • Compile main.C into main, but link filename.o when you build the executable.
    • If you change main, you only need to do the last line.
    • If you change filename.h or filename.C you need to do both.
  • A utility Make
    • A tool for compiling multiple programs
    • This is a rules based system which knows how to construct executable from source coed.
    • It uses a file called Makefile to know what to do.
    • make is old, and the file is a bit cranky
    • There are books on how to do make files, but we will just do some basic operations here.
    • Create Makefile with your editor
    • Build a rule called all which lists the main things you want built.
      • In my case, the main thing I want is myCal
      • all: myCal
    • Tell it how to build myCal
      • In this case, myCal depends on calType.o
      • myCal: calType.o
      • I don't need any special rules following this, but I may in the future
    • Now tell it how to build calType.o
      • It knows that calType.o is built from calType.C, so I only need
      • calType.o: calType.h
    • Finally I build a rule called clean
      • This does not depend on anything.
      • But it has a special action
      • When specifying an action, you need to start with a tab.

      • clean:
        	rm *.o myCal
        	    

    • The entire Makefile is here.