Placing Code in Multiple Files

• This material is covered, along with other things in 12.3.
  • I feel that she mistakenly ties this to objects too tightly.
• How big are some projects
  • Look here.
  • This is old (2020 at least)
• Some of this material will change with C++20
  • In this case we will lean the old way.
  • Most of the code you will see, for a long time, is the old way.
  • Last time I checked, g++ did not implement the new way.
• What we will do
  • I see our friends game as being at three levels of abstraction.
    • The SizeT enum
    • The relationship between SizeT and the game rules.
    • The final game.
  • I might want to use the SizeT enum elsewhere.
  • I want to break the code down so
    • the files contain a logical level of detail.
    • that I could have multiple people work on it.
    • that I can test individual portions.
• I am going to:
  • Build one set of files that represent the SizeT
  • Build one set of files that represent the game abstraction.
  • Build a main program.
• In general, the way you do this is for each level
  • Build a header file that contains definitions other files will need.
    • Type declarations.
    • Constant declarations
    • Function prototypes.
    • BUT NO CODE
  • Build a implementation file that contains the code that implements the descriptions in the header file.
    • This is where the code goes.
  • We will then use the compiler to combine these.
• An aside about the compiler
  • The compiler contains three or four logical items.
  • The preprocessor which is responsible for putting files together for later stages.
    • It is the thing that handles #include <iostream>
    • But it is also programmable
    • We will learn to write one if statement in the preprocessor language
    • And we will learn how to define a variable in the preprocessor language.
  • The Compiler proper
    • Takes the output of the preprocessor and coverts it to a machine like language
  • The optimizer (optional)
    • Takes the output of the compiler and optimizes the resulting code.
  • The linker
    • Links various compiled files into a single executable.
  • Note, syntax errors are not a primary output of the compiler, executable code is.
• Starting Out:
  • Let's move the SizeT stuff to a header file.
    • The file will be called SizeT.h
  • We need to make sure that things are only defined once per compile in c++
    • To do this, we will use one of two methods.
      • Both are preprocessor directives.
      • One is standard, and the other is a defacto standard.
      • I do not care which one you pick.
    • Old style #ifndef
      • For each header file start with

      • #ifndef SOME_VARIABLE_WHICH_WILL_BE_UNIQUE_TO_THIS_FILE
        #define SOME_VARIABLE_WHICH_WILL_BE_UNIQUE_TO_THIS_FILE
        
        // declarations go here
        #endif 

      • This is an if statement in preprocessor
      • The variable does not really matter, but don't start with a _
      • This is standard c++
    • The new style is #pragma once
      • This goes at the top of the file only.
      • it is not standard but notes say that every modern c++ compiler can handle this.
      • This can have technical problems, but not likely.
  • We need to put everything needed in this file.
    • include the string include.
    • The enum declaration
    • The constant declaration
    • The function prototype.
  • But since this CODE will be included in other programmers files we do not want to pollute the name space.
    • No using namespace std;
    • Therefore we need std::string...

  • #ifndef SIZE_T_FOR_CRITTERS
    #define SIZE_T_FOR_CRITTERS
    
    #include <string>
    
    enum class SizeT:char {TINY, SMALL, MEDIUM, LARGE, HUGE, GARGANTUAN, NONE};
    
    const size_t SIZES {static_cast<size_t>(SizeT::NONE)};
    
    std::string SizeTToString(SizeT size);
    int SizeDifference(SizeT first, SizeT second);
    SizeT RandomSize();
    
    #endif

  • See SizeT.h
• Next I am going to build the implementation file.
  • This always includes the header file.
    • This is done with #include "SizeT.h"
    • Note, the " tells the preprocessor to search in the local directory, not the system directories.
  • I always include iostream, I will want to debug.
  • This will be compiled so the code doesn't matter, (use namespace)
  • This is just a normal code file, without a main.
  • See SizeT.cpp
• We need to modify game.cpp.
  • Remove the code moved to the two files.
  • Add #include "SizeT.h"
  • See game.cpp.
• Finally I need to modify the Makefile
  • Add a target for game
  • Add a dependency to build SizeT.o

    SizeT.o: SizeT.h 

  • Add a dependency for game

    game: SizeT.o

  • Makefile