Objectives

• modifying existing code
• overloading operators
• dynamic memory allocation
• writing copy constructors, assignment operators and destructors
• reading data from a file
• using pointers

Classes

You will modify both the Cargo and CargoPlane classes from project 2 in the manner specified below. Modifications and additions to the classes are highlighted in green and marked with . Two new classes will also be required.

The Cargo Class

This class models a single cargo container. As in project 2, Cargo containers are uniquely identified by their label. You may assume that no two containers have the same label.

All private data members of the Cargo class must be dynamically allocated. The Cargo class interface is defined by these public functions:

• Cargo( ) - the Cargo class default constructor
• Cargo (const string& label, int height, int width, int length, double weight) -- another Cargo class constructor
• int GetVolume ( ) -- an accessor which returns the volume of the Cargo container
• double GetWeight( ) -- an accessor which returns the weight of the Cargo container
• const string& GetLabel( ) -- an accessor which returns the label of the Cargo container.
• Cargo ( const Cargo& cargo ) -- Cargo's copy constructor.
• Cargo& operator=( const Cargo& rhs ) -- Cargo's assignment operator
• ~Cargo( ) -- Cargo's destructor

operator<< must be overloaded as a friend of the Cargo class. This operator replaces Cargo's Print( ) function from project 2. operator<< prints all attributes of the cargo container in a format consistent with the

The CargoPlane class

All private data members of the CargoPlane class must be dynamically allocated The CargoPlane class interface is defined by these public functions:

• CargoPlane( ) - the default constructor
• CargoPlane ( double maxWeight, int maxVolume, int fuelCapacity, int fuelRate, const string& city, const FlightTable *flightTablePtr) -- another CargoPlane constructor
• int operator+= (const Cargo& cargo) -- "adds" the Cargo container to the plane. Cargo containers which would cause the plane's weight or volume limit to be exceeded should not be loaded. Returns 1 if the cargo was loaded, -1 if not loaded because the weight limit would be exceeded, -2 if the volume limit would be exceeded and -3 if both limits would be exceeded. This operator replaces the LoadCargo( ) from project 2.
• void operator-= (const string& label) -- "subtracts" the Cargo container with the specified label from the plane. If no cargo container with that label is on the plane, no action is taken and no message is produced. This operator replaces UnLoadCargo() from project 2.
• bool Fly( const string& destination) -- Flies the plane from its current location to the specified city. The number of miles and number of hours (which were parameters in project 2) are found in the CargoPlane's Flight Table. Returns true if the flight was successful. Returns false if the plane crashed because it ran out of fuel. The amount of fuel consumed for a flight is the flight time (in hours) times the fuel consumption rate (in gallons per hour).
• CargoPlane ( const CargoPlane& plane ) -- CargoPlane's copy constructor.
• CargoPlane& operator=( const CargoPlane& rhs ) -- CargoPlane's assignment operator
• ~CargoPlane( ) -- CargoPlane's destructor

1. Current City - the city in which the plane is currently located
2. Miles Flown - the total number of miles flown
3. Hours Flown - the total number of hours flown
4. Fuel Rate - the fuel consumption rate in gallons per hour
5. Fuel Capacity - the plane's fuel capacity in gallons
6. Fuel Consumed - the total gallons of fuel used
7. Fuel Remaining - the total number of unused gallons of fuel
8. Weight Limit - the maximum weight the plane can hold
9. Weight Loaded - the total number of pounds of cargo loaded on the plane
10. Weight Remaining - the total number of pounds that can still be loaded on the plane
11. Volume Limit - the maximum volume of cargo the plane can hold
12. Volume Loaded - the total space occupied by cargo loaded on the plane
13. Volume Remaining - the remaining space that can still be loaded on the plane
14. Current Cargo - a table showing the details of the cargo currently on the plane. If there is no cargo on the plane, an appropriate message should be displayed.
15. Flight Information - a table showing the miles and flight times between all cities serviced by this CargoPlane

The FlightTable class

The CargoPlane has a private data member which is a pointer to a FlightTable object which is constructed and exists in main( ) (or a function called from main).

The FlightTable class supports the following public interface

• FlightTable( ) -- a default constructor
• void AddFlight (const string& origin, const string& destination, int miles, int hours ) -- Adds information for a single flight to the table
• int GetMiles( const string& origin, const string& destination ) -- returns the number of miles from the city of origin to the destination city
• int GetHours( const string& origin, const string& destination ) -- returns the flight time in hours from the city of origin to the destination city.

To encapsulate the information for a single flight, the FlightTable defines a private "embedded" class named Flight. The Flight class can only be used within the FlightTable class. Since this class is known only to the FlightTable class, its design and implementation are up to you, but you must follow good OOP/OOD principles. In particular, all data members of the Flight class must be private. The code for the Flight class may coexist with the code for the FlightTable class.

The Command File

City names in the file have no spaces, so it is possible to use operator>> to read this file (DO NOT use getline()). Each line of the file contains the data for one flight -- origin, destination, miles, hours (in that order).

Summary of Miscellaneous Project Requirements, Restrictions and Assumptions

1. You may assume that both the command file and flight data files exist.
2. You may assume that all input data is valid. You may remove project 2 code that is now unnecessary, or leave it in. In particular this means
   1. The format of the command file and flight files will be valid
   2. The correct number of command line arguments will be present
   3. The values of all data will be valid (eg positive)
   4. You will only be asked to FLY to a city for which flight information exists
   5. The flight data file will contain no duplicate information
   6. The command file will contain no invalid commands
3. All commands must be displayed as they are being executed. Some (or all) of the command parameters must also be displayed. See the sample output.
4. No public methods other than those specified are permitted.
5. You may reorder the parameters in any function, but no new parameters may be added, and no parameter may be removed.
6. The return types of the functions may not be changed (other than using const or reference).
7. The cargo container label may be a multi-word label (eg. Tom's Books).
8. Cargo container labels uniquely identify a container. You may assume that no duplicate containers are loaded on the plane.
9. The maximum weight of the plane may not be exceeded. Any cargo container that would cause the weight limit of the plane to be exceeded must not be loaded.
10. The maximum volume of the plane may not be exceeded. Any cargo container that would cause the volume limit of the plane to be exceeded must not be loaded.
11. Your project must input the cargo data in the following order (same as proj 2). See the command file description above.
    1. label
    2. weight
    3. height
    4. width
    5. length
12. All weight data must be output with 2 decimal points.
13. If your plane crashes, an appropriate message should be displayed, the current plane information displayed (as with the PRINT command) and your program terminated.
14. If a Cargo container cannot be loaded, an appropriate message indicating why it cannot be loaded should be displayed.
15. You may find that you can write your program without using the default constructors for Cargo and CargoPlane, but they must still be implemented, as this is a good programming practice.
16. You may assume that the destination city name (for the FLY command) are one word (i.e. no spaces).
17. You may assume that any command that is entered will not contain spaces
18. Your executable MUST be named Proj3 as that name is used in the testing/grading scripts.
19. We will be using our own "driver" program to test some of your code. You MUST follow the naming conventions found in the Project Submission section below.

1. All numeric columns for Cargo must be aligned and right justified.
   You may assume the Cargo dimensions are no more than 3 digits each
   You may assume the volume is no more than 12 digits
   You may assume the weight is no more than 12 digits (including 2 decimals)
2. All columns for the Flight information must be aligned and right justified
   You may assume that the city names are no more than 20 characters
   You may assume the hours and miles are no more than 5 digits
3. If the plane's weight, volume and fuel data form columns (as in the sample output below) they must be aligned and right justified.
   You may assume that the weight, volume and fuel are no more than 12 digits

• Your project produces all required output
• The output produced is correct for all test cases
• The output is in an acceptable format (see the sample output section)
• Your program contains all required functions and follows good top-down and OOP design principles.

15% - Coding Standards

More complete documentation for submit and related commands can be found here.

Remember -- if you make any change to your program, no matter how insignificant it may seem, you should recompile and retest your program before submitting it. Even the smallest typo can cause compiler errors and a reduction in your grade.

Avoid unpleasant surprises!
Be sure to use the submitmake and submitrun utilities provided for you to compile, link and run your program after you've submitted it.