Objectives

We would like to :

Discuss implementing projects into multiple files

Notes

When dealing with Multiple Files

Header files - hold function prototypes, type definitions and constant definitions.
Implementation Files - function implementations
Using these in a main program.
Compiling Issues

We will do this because it allows us to

Build libraries of reusable code.
Share coding work across multiple people.

We started with decConvert.cpp

This has three main pieces

The function prototype
```
int StringToInteger(string num); 
```
The function implementation

int StringToInteger(string num){
     int value{0};
     size_t i;

     for(i = 0; i < num.size() ; ++i) {
         value = value * 10 + (num[i] -'0');
     }

     return value;
}

The rest of the code

#include <iostream>

using namespace std;

// the function prototype

int main() {

     string num{"489"};

     cout << StringToInteger(num) << endl;

     return 0;
}

// implementation of StringToInteger

We split these into three files

The header file
- Again, this holds only
  - Function prototypes
  - Constant definitions
  - Type definitions
- But only the things we want to export
- We need to include the whatever we need for the function (string)
- We usually don't put using namespace std
- We need to add #pragma once to the top.
- The file converters.h became
```
#pragma once

#include <string>

int StringToInteger(std::string num); 
```
The implementation file
- This holds the code that implements the functions.
- As well as code for any supporting functions.
- No restrictions on what goes in here.
- The file converters.cpp contains
```
#include <iostream>
#include "converters.h"

using namespace std;

int StringToInteger(string num){
     int value{0};
     size_t i;

     for(i = 0; i < num.size() ; ++i) {
         value = value * 10 + (num[i] -'0');
     }

     return value;
} 
```
- We will compile this with g++ -o converters.o -c converters.cpp
- The -c flag says produce an object file, but no executable.
Finally the main program
- We need to #include "converters.h" at the top.
- for include
  - <file> means look in the standard locations
  - "file" means look in the local directory.
- We do not include converters.cpp, we will link with the .o file from above.
- The file converTester.cpp becomes
```
#include <iostream>

#include "converters.h"

using namespace std;

int main() {

    cout << StringToInteger("345") << endl;

    return 0;
} 
```
- To compile this
  1. We need converters.o from above
  2. g++ -o converTester converTester.cpp converters.o

But that is too much work so we added the following lines to the Makefile

OBJS = decConvert converTester
To tell make converters.o relies on converters.h converters.o: converters.h
To tell make converTester relies on converters.o converTester: converters.o
There is no need to tell make that convertTester relies on converters.h, the first dependency does that for us.

We are now relying on three parts of the compiler

C++ preprocessor, or preprocessors
- Combines source code and header files.
- And does other things.
The compiler proper
- Converts c++ code to object code.
- And does other things.
The linker
- Combines object code to produce an executable.
- And does other things.

All three are part of the g++ command.

For those of you who are interested
g++ -e converters.cpp will show the output of the preprocessor
you know g++ -c will compile an object file only.
Gabe: try g++ -v -o file file.cpp