header
//*********************************************************
// GrossPay8.cpp
//
// Calculate and display the gross pay given the hourly
// wage and the number of hours worked.
//
// The purpose of this program is to illustrate the syntax
// used to access components of a dynamically allocated
// structure.
//
//
// D. Searls
// Asbury College
// Dec 2009
//*********************************************************
#include <iostream>
#include <iomanip>
#include <string>
#include <fstream>
using namespace std;

const double MAXHOURS = 40.0;
const double OT_MULTIPLIER = 1.5;
const int MAXSIZE = 100;

struct employeeRecord
{
    string identity;
    double hours;
    double wageRate;
    double grossPay;
};

//*********************************************************
//            M A I N   D R I V E R
//*********************************************************

int main()
{
    employeeRecord* empPtr = NULL;
    ifstream infile;
    string ident;
    double wage;
    double time;

    // Request memory be allocated for a new employee stucture and
    // confirm that the request was granted.
    
    empPtr = new (nothrow) employeeRecord;
    if (empPtr == NULL)
    {
        cout << "FATAL ERROR: Memory allocation failed." << endl;
        exit (0);
    }
    
    // Display the report header

    cout << fixed << setprecision(2);
    cout << "Employee  Gross Pay" << endl;
    cout << "--------  ---------" << endl;
       
    //  Read the data from the file and display the report
    
    infile.open("EmployeeData.txt");
    infile >> ident >> wage >> time;
    while (!infile.fail())
    {
        empPtr->identity = ident;
        (*empPtr).wageRate = wage;
        empPtr->hours = time;
        
        if (empPtr->hours <= MAXHOURS)
        {
            (*empPtr).grossPay = (*empPtr).hours * (*empPtr).wageRate;
        }
        else
        {
            empPtr->grossPay = MAXHOURS * empPtr->wageRate
                               + (empPtr->hours - MAXHOURS)
                               * OT_MULTIPLIER * empPtr->wageRate;
        }
        
        cout << setw(8) << empPtr->identity
             << setw(11) << (*empPtr).grossPay << endl;

        infile >> ident >> wage >> time;
    }
    infile.close();
    
    // Return the memory allocated for the employee back to the
    // operating system.
    
    delete empPtr;
    
    return 0;
}
//*********************************************************
// GrossPay9.cpp
//
// Calculate and display the gross pay given the hourly
// wage and the number of hours worked.
//
// The purpose of this program is to illustrate the syntax
// used to access components of a dynamically allocated
// object.
//
//
// D. Searls
// Asbury College
// Dec 2009
//*********************************************************
#include <iostream>
#include <iomanip>
#include <string>
#include <fstream>
using namespace std;

class employeeRecord
{
private:

// Data members

    string id;        // Employee identifier
    double hours;     // Hours worked
    double wage;      // Hourly wage
  
public:

// Class constructors

    //-----------------------------------------------------
    // Default Constructor
    //
    // Construct a new employee whose identifier is the
    // empty string and whose hours and hourly wage are
    // both zero.
    //-----------------------------------------------------
    employeeRecord()
    {
        id = "";
        hours = 0.0;
        wage = 0.0;
    }
    
    //-----------------------------------------------------
    // Initialization Constructor
    //
    // Preconditions: empHours >= 0
    //                empWage  >= 0
    //
    // Construct a new employee with the specified
    // identifier, hours, and hourly wage. If the specified
    // hours is negative, the employee's hours will be set
    // to zero. If the specified hourly wage is negative,
    // the employee's hourly wage will be set to zero.
    //
    // In Parameters: empId, empHours, empWage
    //-----------------------------------------------------
    employeeRecord(string empId, double empHours, double empWage)
    {
        id = empId;
        
        if (empHours >= 0.0)
        {
            hours = empHours;
        }
        else
        {
            hours = 0.0;
        }
        
        if (empWage >= 0.0)
        {
            wage = empWage;
        }
        else
        {
            wage = 0.0;
        }
    }
    
    //-----------------------------------------------------
    // Copy Constructor
    //
    // Construct a new employee having the same state as
    // the specified employee.
    //
    // In Parameter: emp
    //-----------------------------------------------------
    employeeRecord(const employeeRecord& emp)
    {
        id = emp.id;
        hours = emp.hours;
        wage = emp.wage;
    }

// Member functions

    //-----------------------------------------------------
    // setIdentifier
    //
    // Set the employee's identifier to the specifed value.
    //-----------------------------------------------------
    void setIdentifier(string newId)
    {
        id = newId;
    }
    
    //-----------------------------------------------------
    // setHours
    //
    // Precondition: newHours >= 0
    //
    // Set the employee's hours worked to the specifed
    // value. If the specified value is negative, the
    // employee's hours will not be changed.
    //-----------------------------------------------------
    void setHours(double newHours)
    {
        if (newHours >= 0.0)
        {
            hours = newHours;
        }
    }
    
    //-----------------------------------------------------
    // setWage
    //
    // Precondition: newWage >= 0
    //
    // Set the employee's hourly wage to the specifed value.
    // If the specified value is negative, the employee's
    // wage will not be changed.
    //-----------------------------------------------------
    void setWage(double newWage)
    {
        if (newWage >= 0)
        {
            wage = newWage;
        }
    }
    
    //-----------------------------------------------------
    // getIdentifier
    //
    // Get the employee's identifier.
    //-----------------------------------------------------
    string getIdentifier() const
    {
        return id;
    }

    //-----------------------------------------------------
    // getHours
    //
    // Get the employee's hours worked.
    //-----------------------------------------------------
    double getHours() const
    {
        return hours;
    }

    //-----------------------------------------------------
    // getWage
    //
    // Get the employee's hourly wage.
    //-----------------------------------------------------
    double getWage() const
    {
        return wage;
    }
    
    //-----------------------------------------------------
    // getGrossPay
    //
    // Get the employee's gross pay.
    //-----------------------------------------------------
    double getGrossPay() const
    {
        const double MAXHOURS = 40.0;
        const double OT_MULTIPLIER = 1.5; 
        double grossPay;
        
        if (hours <= MAXHOURS)
        {
            grossPay = hours * wage;
        }
        else
        {
            grossPay = MAXHOURS * wage
                       + (hours - MAXHOURS)
                         * OT_MULTIPLIER * wage;
        }
        return grossPay;
    }      
};

//*********************************************************
//            M A I N   D R I V E R
//*********************************************************

int main()
{
    employeeRecord* empPtr = NULL;
    ifstream infile;
    string ident;
    double wage;
    double time;

    // Request memory be allocated for a new employee stucture and
    // confirm that the request was granted.
    
    empPtr = new (nothrow) employeeRecord;
    if (empPtr == NULL)
    {
        cout << "FATAL ERROR: Memory allocation failed." << endl;
        exit (0);
    }
    
    // Display the report header

    cout << fixed << setprecision(2);
    cout << "Employee  Gross Pay" << endl;
    cout << "--------  ---------" << endl;
       
    //  Read the data from the file and display the report
    
    infile.open("EmployeeData.txt");
    infile >> ident >> wage >> time;
    while (!infile.fail())
    {
        empPtr->setIdentifier(ident);
        (*empPtr).setWage(wage);
        empPtr->setHours(time);
        
        cout << setw(8) << empPtr->getIdentifier()
             << setw(11) << (*empPtr).getGrossPay() << endl;

        infile >> ident >> wage >> time;
    }
    infile.close();
    
    // Return the memory allocated for the employee back to the
    // operating system.
    
    delete empPtr;
    
    return 0;
}