Copyright © 2016, 2022
Robert W. Hasker

Note 7: Modularity in C++

Separate Compilation

Issue: how to avoid having all code in same file?
- Java solution: 1 class per file, make javac work it out
- Limitation: less flexibility for developers
  - If autogenerate Java code, must respect the hierarchy
  - Additional detail for autogenerators: must provide mechanism to specify packages, etc.
- C (and C++) solution: #include
  - general mechanism for including one source file in another during compilation
  - core concept: compilers see a compilation unit - collection of source files
  - linker: combine compilation units
    - when have run-time libraries, ld combines units
  - result: developer can be in charge of file naming, organization
  - libraries work like any other bit of code

Writing your own `.h` files

C++ header files
- typically have the extension ".h"
  (except library files in standardized C++)
- use #include to make compiler "read" the header file
- header file inserted into the code just as if you typed it in right there
Example code with multiple files:
- ave.h, ave.cpp, printave.cpp
  - Compiling:
```
        g++ -c printave.cpp
        g++ -c ave.cpp
        dir                     # note the .o files
        g++ ave.o printave.o
        dir                     # now have a.exe
```
  - Input 15 items into printave
  - Input 30 items into printave
- Note the quotes in #include "ave.h"
  - use angle brackets for libraries, quotes for project-specific includes
- of course, would typically have prototypes for several functions in the .h file
string is another file that consists of just prototypes (and class definitions)
recall:
- declaration: state something exists
- definition: give that thing a value
cstring: C-style string function prototypes
interface: information needed to use definitions
- typically, the declarations define the interface
what goes into which file is basically simple:
- .h files: function declarations (prototypes) and type definitions (struct, class definitions)
  - these define the interface
- .cpp files: function definitions
  - these define the implementations

Review of Compilation Process

Compilation in Ch. 1:

                                     libraries
                                         |
                                         v
.--------.  .cpp  .----------.   .o  .--------.
| Editor |------->| compiler |------>| linker |--> .exe
`--------'        `----------'       `--------'

More detail:

               .h files                                  libraries
                   |                                         |
                   v    compilation                          v
.--------. .cpp .-----.  unit (.i)    .----------.  .o   .--------.
| Editor |----->| CPP |-------------->| compiler |------>| linker |--> .exe
`--------'      `-----'               `----------'       `--------'
                                                             ^
                                                             |
                                                        other .o's

CPP: C Pre-Processor
- jobs:
  1. handle macros (#define) - won't use for now
  2. remove comments
  3. replace #include "filename" by contents of file
    - #include <file>: look in standard directories ("libraries") for given file
    - #include means "insert copy here"
note the difference between angle brackets and double quotes
- #include <file> means look in standard directories
- #include "file" means insert file from current directory
  - that is, the file is part of the project
- generally, CPP handles the preprocessor directives

example:

source files:

x.cpp:

        #include <math>
        #include "print.h"
        void main()
        {
           prdbl(sqrt(2.0));
        }

math:

        double sqrt(double);
        double sin(double);
        // etc.

iostream: istream, ostream classes plus declarations for cin and cout

print.h
```
        void prdbl(double);
```
- print.cpp would include iostream!

cpp -x <x.cpp gives the compilation unit

        double sqrt(double);
        double sin(double);
        // etc.
        void prdbl(double);
        void main()
        {
           prdbl(sqrt(2.0));
        }

Note cpp here is the C pre-processor
Alternatively: cpp -x printave.cpp > printave.i

Problem: what if include file more than once?
- Example: see full todo list
- Note tasklist.h includes task.h
  day.cpp could include both tasklist.h and task.h
  Result: task.h gets included more than once - error (implies multiple definitions of class Task)
- solution: use a bit of compiler directive magic; put
```
        #ifndef task_h
        #define task_h
```
  at top of Task.h (in general, use file_h for header file file) and
```
        #endif
```
  at bottom
  - this forces CPP to skip any later includes of the same file, so each compilation unit contains just one copy of class Task
- all system libraries use this technique
  - in Visual C++ and many others, can use #pragma once - works, but isn't portable; I want you to use the #ifndef in files you create
note! - never use #include to include one .cpp file in another. If you write
```
        #include "x.cpp"
```
you're doing something wrong!
- that's why IDEs have a notion of "projects"
- a project is a collection of .cpp files that must be compiled together to build an executable
Design principles for separate compilation
- class/module xyz: xyz.h and xyz.cpp
- ensure xyz.h can be included multiple times
- xyz.h must be complete: if it refers to something in another header, include that header
  - Or, don't even include the header: if just have X* data, can simply write
```
        class X;
```
    to declare that X is a class.
- Do not put "using namespace std;" in a .h file
  - use std::string whenever refer to standard classes
- First code in xyz.cpp: #include "xyz.h"
  - makes sure xyz.h is complete
  - generally include system libraries last - helps identify errors sooner rather than later

Namespaces

Another way to control scope - where an identifier is visible
- Issue: two programmers could easily make a class Point with different purposes
- namespace: a way to (say) ensure the point used for the UI is different than the point used for calculating distances between GPS coordinates

declaring namespaces:

   namespace myNames
   {
      void getData(int&);
   };
   namespace yourNames
   {
      void getData(int&);
   };

For example, file iostream

        namespace std {
           class istream { ... };
           istream cin;

           class ostream { ... };
           ostream cout;
        };

and file string:

        namespace std {
           class string { ... };
        };

hence the need for using namespace std or std::cin, std::string

defininitions:

   namespace myNames
   {
      void getData(int &x) { ... }
   };
   void yourNames::getData(int &y) {...}

calling methods:

   int i;
   myNames::getData(i);
   yourNames::getData(i);

using function:
```
    using myNames::getData;
```
All calls to getData now refer to myNames implicitly
using namespace:
```
    using namespace myNames;
```
for easy access to everything
string, cin, cout are all names in namespace std
- Private versions of these would be silly!
- If code compiles with either a::f or b::f and correctness depends on which one you use, reconsider your naming scheme!
- Stack overflow: "using namespace" is bad
- Stroustrup: uses using clauses everywhere!

Review

declarations vs. definitions
separate compilation
header (.h) files
#include
#ifndef, #define, #endif
c preprocessor (cpp)
organizing #includes
namespaces

Copyright © 2016, 2022 Robert W. Hasker