Building Code from Multiple Files.

• Given the compiler scheme we discussed last time, we should be able to expand the first part to include compiling code across multiple files.
• Assume that I want to build the following programs:
  • A calculator that works with numbers in different bases.
  • A quiz program that helps people learn how to work in different bases
  • A program to test to see if our base conversion routines are working.
• Remember the discussion from last time,
  • Right now, I would have to make multiple copies of the routines
    • string IntToNum(int number, int base);
    • int StringToInt(string number, int base);
    • char DigitToChar(int digit);
    • int CharToDigit(char c);
  • And if there were a bug, I would have to fix it in every location.
  • That would be bad.
  • And clearly that is not what is done, otherwise you would have to put the code for cin, cout, string, ... in every program that used these features.
• The idea is to build multiple object files which the linker can build into a single executable.
• 
• But remember
  • In C/C++ everything must be defined before it can be used.
    • This is the purpose of
      • variable declarations
      • constant declarations
      • function prototypes.
    • So we will need to define things once and share this declaration across multiple files.
  • In C/C++ things may only be defined once within a scope
    • So we will need some way to "protect" our definitions from happening multiple times.
• User defined header files.
  • User defined header files are used to declare objects that are shared across files.
  • Just like system header files.
  • They generally include
    • type definitions
    • function prototypes
    • constant definitions.
  • They generally do not include
    • source code.
    • variable definitions.
  • usually have a .h extension.
• For our example
  • I would like to break the code into two support sections
    • digits which will provide routines to support conversion between digits in base ten and other bases.
    • numbers which will provide routines to support conversion between numbers in different bases.
  • I will build four new files
    • digits.h : the definition of the digits routines
    • digits.C : the implementation of the digits routines
    • numbers.h : the definition of the numbers routines
    • numbers.C : the implementation of the numbers routines
  • I will also build some new "main" programs
    • digitsTest.C: a program that tests the digits routines
    • numbersTest.C : a program that tests the numbers routines
    • calculator.C : a program that is a multibase calculator.
• The header files.
  • digits.h is a very small file.
  • at first glance digits.h might be

    char DigitToChar(int digit);
    int CharToDigit(char c);
    	

  • And numbers.h might be

  • string IntToNum(int number, int base);
    int StringToInt(string number, int base);
    	

  • But this has several problems
    • First of all, string will be a problem.
      • For some compilers we will need to #include <string>
      • This is no problem
    • we have not added using namespace std; so the compiler does not know to look in the standard namespace for string.
      • This is a bit of a problem.
      • We could using namespace std;
      • But this would lead to namespace pollution
      • Or we could just provide the scope for string.
      • Either is fine, I will do the latter.

      • std::string IntToNum(int number, int base);
        int StringToInt(std::string number, int base);
        		 

      • std::string tells that compiler to look in the standard namespace for the definition of string.
    • Finally, we need to make sure that these function are not defined multiple times if the .h file is included more than once.
      • To do this we use a preprocessor trick called #define guard
      • At the top of the file place

      • #ifndef SOME_UNIQUE_STRING
        #define SOME_UNIQUIE_STING
        		

      • And at the bottom of the file

      • #endif
        		

      • no joke, look at /usr/include/limits.h
      • Or even the Google C++ Style Guide
  • So here is the final digits.h.
  • And the final numbers.h.
• The new source or implementation files.
  • They should include the header files we have just defined.
    • But we need to tell the compiler to look in the local directory, not the normal search space.
    • So we use #incldue "digits.h"
  • There should be no main routine in these files, they are just support code.
  • I usually add #include <iostream>, for debugging purposes if nothing else.
  • I usually add using namespace std because I do not like adding std:: to every identifier from the standard namespace.
  • All of the code needed should be in the files.
    • digits.C
    • numbers.C
• Finally a couple of programs
  • Each should have a main routine.
  • Each should include whaterver is needed.
  • digitTest.C
  • numberTest.C
  • calculator.C, really just a shell.
• We will compile these in the next set of notes.