One view of object oriented programming (OOP) is programming using data types to model real-world objects; that is, defining data objects to model "real-world" objects and operating on those objects to perform a computation. The problem is that the pre-defined C++ types (int, double, char, etc.) are fine for modeling numeric data and some text data but many real-world objects are not numbers or characters. We want to create new data types to model such non-alphanumeric objects. The objective of this lab exercise is to show how it is possible to extend the programming language C++ by adding these new data types to it.

→ In this lab exercise, you will be using the program source_lab04_geology.cpp. Please download this file to your home directory and rename it to geology.cpp.

Problem: To model and process rocks (basalt, dolomite, granite, limestone, marble, obsidian, quartzite, and sandstone).

Approach #1 (the "old-fashioned" approach)

Code each rock with an integer code and use int to model rocks.

int rock1, rock2;

// Set rock1 to basalt, rock2 to quartzite
rock1 = 0;
rock2 = 6;

• We must remember the order in which the rocks are represented (which is first, which is second, ...).
• We must remember their numeric codes.
• The situation gests worse as the number of rocks increases. And it's a waste of time for a programmer to have to remember this trivia, especially when the compiler can do it!

Look at the program geology.cpp to see what it does. Note the sequence of const declarations. Compile the program and execute it.

1. What happens if you enter the name of a rock such as BASALT?
   
   
   
   
   
2. Execute the program and enter the numeric codes of basalt, dolomite, and granite. Describe the output produced:
   
   
   
   
   

Approach #3: Use an enumerated type.

The problem in the preceding approach is that we are representing real-world objects (rocks) with integer codes (0, 1, 2, ...) instead of using their "real-world" names (basalt, dolomite, granite, ...). C++ provides an enumeration mechanism that allows a programmer to define a new data type whose values are those real-world names. In this lab exercise, we will create a new data type Rock whose values are the names of the rocks, instead of integers.

A Brief Summary of Enumerations

In earlier programming languages, it was necessary to use numeric codes to represent real-world objects; for example, using 0, 1, 2, 3, ... to represent rocks instead of using their real-world names (asalt, dolomite, granite, limestone, ...). The problem with this is the difficulty of remembering these codes and reading instructions for processing objects using these codes. C++ provides the enumeration mechanism that allows a programmer to define a new data type whose values are those real-world names.

The following is an enumeration declaration for a new data type Color whose values (called enumerators) are the colors RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, and VIOLET followed by a COLOR_OVERFLOW value:

enum Color {RED, ORANGE, YELLOW, GREEN,
            BLUE, INDIGO, VIOLET, COLOR_OVERFLOW};

As another example, the declaration

enum Gender {FEMALE, MALE};

enum HandTool {HAMMER, PLIERS, SAW, SCREW_DRIVER};

C++ also allows the programmer to specify explicitly the values given to the enumerators. For example, the declaration

enum NumberBase {BINARY = 2, OCTAL = 8, DECIMAL = 10,
                 HEX = 16, HEXADECIMAL = 16};

enum Color {RED = 1, ORANGE = 2, YELLOW = 3, GREEN = 4,
            BLUE = 5, INDIGO = 6, VIOLET = 7, COLOR_OVERFLOW = 8};

enum Color {RED = 1, ORANGE, YELLOW, GREEN,
            BLUE, INDIGO, VIOLET, COLOR_OVERFLOW};

3. In the space below, write an enumeration declaration for a new data type Rock whose values (enumerators) are the rock names BASALT, DOLOMITE, GRANITE, LIMESTONE, MARBLE, OBSIDIAN, QUARTZITE, and SANDSTONE, followed by a ROCK_OVERFLOW value.
   
   
   
   
   
4. Now modify Part 1 of program geology.cpp as follows:
   → Replace the 9 const defniitions with this enumeration declaration.
   → Change the type of sample from int to Rock.
   Attempt to recompile and execute the program. describe any errors that occur.
   
   
   
   
   As the error messages should indicate, one difficulty is that the input operator >> is not defined for our new type Rock. This will be fixed later in the lab exercise but, for the time being, make the following "quick-and-dirty" patch:

   Replace the offending statement

       cin >> sample;
       

   with:

       int temp; cin >> temp; sample = Rock(temp);
       

5. Recompile and execute the program as before, entering the numeric codes of basalt, dolomite, and granite. Describe any differences between this program's output and that in Approach 2.
   
   
   
   
   
6. Now modify Part 2 of program geology.cpp as follows:
   → Change the type of rockVal in the second for loop from int to Rock.
   Attempt to recompile and execute the program. Describe any errors that occur.
   
   
   
   
   As the error messages should indicate, the difficulty is that the ++ operator (either in postfix or prefix form) is not defined for our new type Rock. We will remedy this problem shortly.

A data type has two components:

1. A collection of values

2. Operations on those values

Header file

The header file is the interface between the data type and the user, so it must be documented thoroughly. It's opening documentation should include (at least) the following items (and other items from the Programming Style Sheet):

• The name of the programmer
• When the program was written/modified
• A description of the data type being defined, including a list of all the operations and brief descriptions of them.

• The type declaration(s)
• Function prototypes for each operation on the new type

7. Create a header file rock.h containing:
   → Opening documentation (items listed above and in the Programming Style Sheet, e.g.)
   → The Rock enumeration declaration
   Note: Since some of the functions will use the types istream and ostream, put:

       #include <iostream>
       using namespace std;
       

   directives at the beginning of this header file.
8. Now add:

       #include "rock.h"
       

   at the beginning of geology.cpp and remove the enumeration declaration of type Rock. Recompile geology.cpp to check that there are no new compilation errors — only the ++ error from 6.

We will first consider the problem in the for loop in Part 2 of geology.cpp:

for (Rock rockVal = BASALT; rockVal <= SANDSTONE; rockVal++)
    cout << rockVal << " ";

The problem is that the increment operator ++ is defined for integers but not for Rocks. You will now construct a function Next() that returns the successor of a rock and use it in place of the ++ operation. (In Lab 4 we will see how the operator ++ can be overloaded for type Rock so that this for loop will execute.)

9. Modify the for statement in Part 2 of geology.cpp as follows (so it can be used to test Next()):

       for (Rock rockVal = BASALT; rockVal <= SANDSTONE;
                                              rockVal = Next(rockVal))
           cout << rockVal << " ";
       

   A specification for Next() is as follows:

   Receive:

   A Rock value rockVal

   Return:

   The successor of rockVal (the successor of the last enumerator SANDSTONE is ROCK_OVERFLOW)

10. Add the following function prototype to rock.h:

        Rock Next(Rock rockVal);
        

    and appropriate documentation (as per the Programming Style Sheet).

    → Each function prototype should be accompanied by a block comment giving the following:

    • In the first line, a description of what the function does
    • A specification of the function in terms of what it receives, returns, and I/O (if any)
    • Any other information that the person using the library needs to know to use the function
    → Include meaningful parameter names in the function prototypes (rather than simply type names) as this also helps describe how to use the function.

The implementation file contains:

→ The definitions of the operations (functions) on the new type.

→ These are preceded by a #include directive to insert the library's header file (so the compiler can check that the prototypes and definitions match).

11. Complete the following definition of Next() and put it in rock.cpp:

        Rock Next(Rock rockVal) {
          switch (rockVal) {
            case BASALT:     return DOLOMITE;
            case DOLOMITE:   return GRANITE;
            . . .
            default:
              // Output an error message and return the ROCK_OVERFLOW value
           }
        }
        

Compiling and Linking

The directive #include "rock.h" causes the compiler (actually, the preprocessor) to insert the declaration of ^Rock and the prototype for function Next() into geology.cpp. However, the definition of Next() is in rock.cpp, not in geology.cpp.

Translating a program like geology.cpp to produce a binary executable program involves two phases:

1. Compiling, in which C++ code is translated into machine language; and
2. Linking, in which calls to functions outside the main file are linked to their definitions.

Step 1:

Separately compile the program file name.cpp to produce an object file named name.o in some systems. This may require using a special compiler switch, as in the GNU C++ command:

      g++ -c geology.cpp
      

geology.cpp

→

geology.o

Step 2:

Separately compile ech library implementation file in the same manner; for example:

      g++ -c rock.cpp
      

rock.cpp

→

rock.o

Step 3:

Link the object files together into a binary executable program — for example, in GNU C++ with the command:

      g++ geology.o rock.o -o geology.exe
      

geology.o	→	geology.exe
rock.o	→

If a program involves several different libraries, it can be very difficult to keep track of which files are out of date, which need to be recompiled, and so on. Single commands like the preceding that do this automatically are very usefull in this regard. With GNU C++, UNIX's make utility can be used to execute a file named Makefile that contains the commands for the compilations and linking.

Defining a Rock Kind Operation

12. Add another function Kind() to type Rock that returns one of the strings "igneous", "metamorphic", or "sedimentary" that indicates the kind of a rock, using the following information:
    • Basalt, granite, and obsidian are igneous
    • Marble and quartzite are metamorphic
    • Dolomite, limestone, and sandstone are sedimentary
13. Add a for loop in geology.cpp to test drive this function by displaying the kinds of all the rocks. Compile, link, and execute the modified program to ensure that Kind() works.

Hand In:

1. This lab handout with the answers filled in
2. Listings of rock.h and rock.cpp (use the enscript command from your Programming Style Sheet:
   enscript -E -G -2rj -M Letter -PECT2_PS <filename>. Or, you can use the a2ps command: a2ps <filename>)
3. A listing of geology.cpp (use the enscript command from your Programming Style Sheet:
   enscript -E -G -2rj -M Letter -PECT2_PS geology.cpp. Or, you can use the a2ps command: a2ps geology.cpp))
4. A demonstration that everything compiles and links correctly
5. A sample run of geology.cpp