Copyright © 2016
Robert W. Hasker

Note 7: Modularity in C++

Ch. 3 of textbook

Declarations vs. Definitions

• Declaration: int x;
• Definition (of a variable): int x = 5;
  • value as well as type
  • definition of a pointer: int *p = new int; (sets address, but doesn't set value at that address)
• Definition of a class:

          class A { public: int f() { return 42; } };
  

  • Can also declare classes: class A;
  • Generally: declarations just say something exists
• Declaring a function: a function prototype
  • double sqrt(double); // parameter name not needed
  • int strlen(const char* text);
  • int strcmp(const char* a, const char* b);
  • char* strcpy(char* dest, const char* src);
• Defining a function:

      // untested, from http://tinyurl.com/zy8scsu
      #include <math.h>
  
      double sqrt(double x) {
          if (x <= 0)
              return 0;       // if negative number throw an exception?
          int exp = 0;
          x = frexp(x, &exp); // extract binary exponent from x
          if (exp & 1) {      // we want exponent to be even
              exp--;
              x *= 2;
          }
          double y = (1+x)/2; // first approximation
          double z = 0;
          while (y != z) {    // yes, we CAN compare doubles here!
              z = y;
              y = (y + x / y) / 2;
          }
          return ldexp(y, exp / 2); // multiply answer by 2^(exp/2)
      }
  

• Fundamental rule in C++: identifiers must be declared before any references (where "before" includes "somewhere in the same class")
  • "Identifiers" includes functions, classes, structs, variables, etc.
  • definitions can appear elsewhere, even in a different file
  • libraries: collections of definitions with prototypes in a special file
• Separating declarations from definitions for class methods:

          class ToDo {
          public:
             ToDo();
             bool empty();
             bool full();
             void add(string next_item);
             string next_item();
          private:
             string *items;
             int count, capacity;
          };
  
          ToDo::ToDo() : count{0}, capacity{100}, items{new string[100]} { }
  
          bool ToDo::empty() { return count == 0; }
  
          void ToDo::add(string next_item) {
             if ( count >= capacity ) {
                string *old_items = items;
                items = new string[capacity * 2];
                capacity *= 2;
                for(int i = 0; i < count; ++i)
                   items[i] = old_items[i];
                delete[] old_items;
             }
             items[count] = next_item;
             ++count;
          }
  
          string ToDo::next_item() {
             if ( empty() )
                throw "Removing item from empty todo list.";
             string result = items[0];
             for(int i = 0; i < count - 1; ++i)
                items[i] = items[i + 1];
             --count;
             return result;
          }
  

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  .----------. .obj  .--------.
  | Editor |------->| compiler |------>| linker |--> .exe
  `--------'        `----------'       `--------'
  

• More detail:

                 .h files                                  libraries
                     |                                         |
                     v    compilation                          v
  .--------. .cpp .-----.  unit (.i)    .----------. .obj  .--------.
  | Editor |----->| CPP |-------------->| compiler |------>| linker |--> .exe
  `--------'      `-----'               `----------'       `--------'
                                                               ^
                                                               |
                                                          other .obj'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&);
     };
  

• 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!

Exceptions

• assert: a simple mechanism for checking preconditions
  • see ave.cpp
  • #include <cassert>
  • simple, but impossible for client to recover from error
  • intent: localize errors during debugging
  • Illustrate: call getAve with size = 0
• Other issues:
  • Assert calls abort() - crashes program, creates "core" image on some systems
  • abort() means standard output (cout) is not flushed
  • That is, some text can have been printed but held in a buffer
  • One solution: call cout.flush() after key output
  • Another: send debug output to cerr - this is not buffered
• assert: simple, direct tests
  • Can be very useful for adding precondition checks to code during debugging
• better error handling: exceptions
• Exceptions are very similar between Java and C++
• No base class for all exceptions
  • (Actually, there is an exception class in the STL, but this is not a required element of the core language.)
• silly example:

     #include <iostream>
     #include <math>
     using namespace std;
  
     int main()
     {
        while ( true )
        {
           try
           {
              cout << "Enter number: ";
              double num;
              cin >> num;
              if ( num < 0 )
                 throw "sqrt of negative";
              cout << "Sqrt of num is " << sqrt(num) << endl;
           }
           catch (const char msg[])
           {
              cerr << "Error: " << msg << endl;
              // if we are using exceptions to check for negatives, might
              //    as well just use random returns to exit a loop
              return 1;
           }
        }
        return 0;                 // but just how executed?...
     }
  

• Of course, we would never use exceptions for standard processing
• More reasonable example:

          double ave(const double numbers[], int size) {
             if ( size <= 0 )
                throw std::domain_error("Average domain error: size less than 1");
             auto sum = 0.0;
             for(auto i = 0; i < size; ++i)
                sum += numbers[i];
             return sum / size;
          }
  

• introducing a datatype for exception gives flexibilty - can trap right one
  • standard exceptions: domain_error, invalid_argument, out_of_range, etc.
• No need to declare what exceptions a function throws.
  • can declare it, but see SO for a good discussion
• Can use noexcept to declare function does not throw anything (see textbook).
  • If function does throw an exception in that case, program terminates with an error.
  • This may be the only guaranteed behavior for declared exceptions...
• see also the textbook discussion of static_assert - checks done at compile time

Review

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