View difference between Paste ID: niJMYu0x and iqnYUiUc

 #include <cstdlib>
 #include <iostream>
 #include <iomanip>
 #include <cmath>
 
 using namespace std;
 
 //declare function prototypes
 void displayWelcomeMessage();
 void getInput(double *EmployeeID, double *hoursWorked, double *payRate, char *unionCode, char A, char B, char C, double *regularPay, double *overtimePay);
 double calculateGrossPay(double *grossPay, double regularPay, double overtimePay);
 void calculateFederalTax(double grossPay, double *federalTax, double *paidTax);
 void calculateUnionDues(char unionCode, double *unionDues);
 double calculateNetPay(double *netPay, double grossPay, double paidTax, double unionDues);
 void displayEmployeeInputInfo(double employeeID, double hoursWorked, double payRate, char unionCode);
 void displayEmployeeCalculationResults(double regularPay, double overtimePay, double grossPay, double federalTax, double unionDues, double netPay);
 void displayPayrollSummaryInfo(int numEmployees, double totalGrossPay, double highestGrossPayEmployeeID, double highestGrossPay, double lowestGrossPayEmployeeID, double lowestGrossPay, double averageGrossPay);
-void displaylowGrossID(double lowAverageID[]);
+void displaylowGrossID(double lowAverageID[], double grossPay[]);
 void displayTerminationMessage();
 
 //initialize the program
 int main()
 {
            displayWelcomeMessage();
            // local variable declarations
            int numEmployees = 0; //number of employees processed
            double totalGrossPay = 0; //total gross pay
            double highestGrossPay = 0; //highest gross pay
            double highestGrossPayEmployeeID = 0; //counter to identify employeeID with highest gross pay
            double lowestGrossPay = std::numeric_limits<double>::infinity(); //lowest gross pay
            double lowestGrossPayEmployeeID = 0; //counter to identify employeeID with lowest gross pay
            double averageGrossPay;//average gross pay is totalgrosspay / numemployees
            double lowAverageID[4]; //Employees whose gross pay is less than average
            double employeeID[5]; // employee's ID number
            double hoursWorked[5]; // number of hours employee worked
            double payRate[5]; // employee's pay rate
            char unionCode[5]; // employee's one character union code
            char A = 'A'; // unionCode A
            char B = 'B'; //unionCode B
            char C = 'C'; //unionCode C
            double regularPay[5]; // if hoursWorked <=40 then regular pay = hoursWorked * payRate
            double overtimePay[5]; // if hoursWorked >40 then over times pay = 1.5 * (hoursWorked - 40) * payRate
            double grossPay[5]; // gross pay is hoursWorked times payRate
            double federalTax[5]; // amount of tax employee pays based on grossPay
            double paidTax[5]; // paidTax is grossPay - netPay
            double unionDues[5]; // dues paid based on unionCode
            double netPay[5]; // netPay is grossPay - (grossPay * federalTax)
 
-           for (int x = 1; x <=2; x++) // loop program 2 times
+           for (int x = 0; x < 5; x++) // loop program 2 times
            {
            //functions
            getInput(&employeeID[x], &hoursWorked[x], &payRate[x], &unionCode[x], A, B, C, &regularPay[x], &overtimePay[x]);
            calculateGrossPay(&grossPay[x], regularPay[x], overtimePay[x]);
            calculateFederalTax(grossPay[x], &federalTax[x], &paidTax[x]);
            calculateUnionDues(unionCode[x], &unionDues[x]);
            calculateNetPay(&netPay[x], grossPay[x], paidTax[x], unionDues[x]);
            displayEmployeeInputInfo(employeeID[x], hoursWorked[x], payRate[x], unionCode[x]);
            displayEmployeeCalculationResults(regularPay[x], overtimePay[x], grossPay[x], paidTax[x], unionDues[x], netPay[x]);
 
            numEmployees++; //counter for number of employees to process
-           totalGrossPay += grossPay[numEmployees]; //counter for total gross pay
+           totalGrossPay += grossPay[x]; //counter for total gross pay
            averageGrossPay = totalGrossPay / numEmployees;
            //highest gross pay employee ID
            if( grossPay[x] > highestGrossPay )
                {
                    highestGrossPay = grossPay[x];
                    highestGrossPayEmployeeID = employeeID[x];
                }
            //lowest gross pay employee id
            if( grossPay[x] < lowestGrossPay )
                {
                    lowestGrossPay = grossPay[x];
                    lowestGrossPayEmployeeID = employeeID[x];
                }
-           //employees with lower than average gross pay
+
            }
            //employees with lower than average gross pay
            for (int x = 0; x < 5; x++){
-               }
+
                {
                    lowAverageID[x] = employeeID[x];
                }
                }
-           displaylowGrossID(lowAverageID);
+
            displayPayrollSummaryInfo(numEmployees, totalGrossPay, highestGrossPayEmployeeID, highestGrossPay, lowestGrossPayEmployeeID, lowestGrossPay, averageGrossPay);
            //display employees with below average gross pay
            displaylowGrossID(lowAverageID, grossPay);
            //display termination message
            displayTerminationMessage();
 
            system("PAUSE");
            return 0;
 }
     //function definitions
     // Welcome message
     void displayWelcomeMessage()
         {
             std::cout << "My Payroll Calculator\n\n\n";
         }
     //get inputs from user
     void getInput(double *EmployeeID, double *hoursWorked, double *payRate, char *unionCode, char A, char B, char C, double *regularPay, double *overtimePay)
         {
             std::cout << "EmployeeID: "; //request user input for EmployeeID
             std::cin >> *EmployeeID;   // read input from user into employeeID
             std::cout << "Hours worked: "; // request user input for hoursWorked
             std::cin >> *hoursWorked; // read input from user into hoursWorked
             while (*hoursWorked <0 || *hoursWorked > 60) // only allow input from 0-60
                 {
                     std::cout << "Error! You must enter a value between 0 and 60\n";
                     std::cout << "Hours worked: ";
                     std::cin >> *hoursWorked;
                 }
             std::cout << "Pay rate: "; // request user input for payRate
             std::cin >> *payRate; // read input from user into payrate
             while (*payRate <7.50 || *payRate > 45.00) //only allow input from 7.50 - 45.00
                 {
                     std::cout << "Error! You must enter a value between 7.50 and 45.00\n";
                     std::cout << "Pay rate: ";
                     std::cin >> *payRate;
                 }
             std::cout << "Union code A, B, or C? "; // request user input for unionCode
             std::cin >> *unionCode; // read input from user into unionCode
             while (*unionCode !=A && *unionCode !=B && *unionCode !=C) //only allow input A, B, or C
                 {
                     std::cout << "Error! Your code must be A, B, or C\n";
                     std::cout << "Union code: ";
                     std::cin >> *unionCode;
                 }
             *regularPay = *hoursWorked * *payRate; // calculate regularPay
             *overtimePay = 1.5 * ( *hoursWorked - 40 ) * *payRate; // calculate overtimePay
             if ( *hoursWorked <= 40) *overtimePay = 0;//determine if there is overtime pay or not
             if ( *hoursWorked > 40) *regularPay = *payRate * 40;
         }
     // calculate grossPay
     double calculateGrossPay(double *grossPay, double regularPay, double overtimePay)
         {
             *grossPay = regularPay + overtimePay;
             return *grossPay;
         }
     // calculate paidTax
     void calculateFederalTax(double grossPay, double *federalTax, double *paidTax)
         {
             if ( grossPay > 2000 ) *federalTax = .25; // determine federal tax rate
             else if ( grossPay >= 1000 ) *federalTax = .15;
             else *federalTax = .1;
             *paidTax = grossPay * *federalTax;
         }
         // calculate unionDues
     void calculateUnionDues(char unionCode, double *unionDues)
         {
             switch (unionCode)
                 {
                     case 'A': *unionDues = 25;
                     break;
                     case 'B': *unionDues = 50;
                     break;
                     case 'C': *unionDues = 75;
                     break;
                 }
         }
     // calculate netPay
     double calculateNetPay(double *netPay, double grossPay, double paidTax, double unionDues)
         {
             *netPay = grossPay - paidTax - unionDues;
             return *netPay;
         }
     //display employee input info
     void displayEmployeeInputInfo(double employeeID, double hoursWorked, double payRate, char unionCode)
         {
             std::cout << "\nIdentification Number: " << employeeID; //display employeeID
             std::cout << "\nHours Worked: " << hoursWorked; //display hoursWorked
             std::cout << "\nPay Rate: " << payRate; //display payRate
             std::cout << "\nUnion Code: " << unionCode; //display unionCode
         }
     //display employee calculation results
     void displayEmployeeCalculationResults(double regularPay, double overtimePay, double grossPay, double federalTax, double unionDues, double netPay)
         {
             std::cout << fixed << setprecision(2); //format output to 2 decimal places
             std::cout << "\nRegular Pay: " << regularPay; //display regularPay
             std::cout << "\nOvertime Pay: " << overtimePay; // display overtimePay
             std::cout << "\nGross Pay: " << grossPay; // display grossPay
             std::cout << "\nFederal Tax: " << federalTax; // display federalTax
             std::cout << "\nUnion Dues: " << unionDues; // display unionDues
             std::cout << "\nNet Pay: " << netPay; // display netPay
             std::cout << fixed << setprecision(0); //format output to 0 decimal places
             std::cout << "\n\n";
         }
     //display payroll summary info
     void displayPayrollSummaryInfo(int numEmployees, double totalGrossPay, double highestGrossPayEmployeeID, double highestGrossPay, double lowestGrossPayEmployeeID, double lowestGrossPay, double averageGrossPay)
         {
             std::cout << "\nEmployees Processed: " << numEmployees; //display number of employees processed
             std::cout << fixed << setprecision(2); //format output to 2 decimal places
             std::cout << "\nTotal Gross Pay: " << totalGrossPay; //display total gross pay
             std::cout << fixed << setprecision(0); //format output to 0 decimal places
             std::cout << "\nEmployee With Highest Gross Pay: " << highestGrossPayEmployeeID; //display ID of employee with highest gross pay
             std::cout << fixed << setprecision(2); //format output to 2 decimal places
             std::cout << "\nHighest Gross Pay: " << highestGrossPay; //display highest gross pay
             std::cout << fixed << setprecision(0); //format output to 0 decimal places
             std::cout << "\nEmployee With Lowest Gross Pay: " << lowestGrossPayEmployeeID; //display ID of employee with lowest gross pay
             std::cout << fixed << setprecision(2); //format output to 2 decimal places
             std::cout << "\nLowest Gross Pay: " << lowestGrossPay; //display lowest gross pay
             std::cout << "\nAverage Gross Pay: " << averageGrossPay; //display average gross pay
-    void displaylowGrossID(double lowAverageID[])
+            std::cout << fixed << setprecision(0);
             std::cout << "\n";
-            for (int x = 1; x <= 4; x++)
+
     //display employess with below average gross pay
-                    std::cout << "\nEmployees With Below Average Gross Pay: ";
+    void displaylowGrossID(double lowAverageID[], double grossPay[])
-                    std::cout << lowAverageID[x] << endl;
+
             std::cout << "\nEmployees With Below Average Gross Pay:\n";
             for (int x = 0; x < lowAverageID[x]; x++)
                 {
                     cout << lowAverageID[x] << "  --  $" << grossPay[x] << endl;
                 }
         }
     //display termination message
     void displayTerminationMessage()
         {
             std::cout << "\nBest payroll calculator in the whole world\n\n"; // Termination message
         }