fork download

copy

//********************************************************
//
// Assignment 6 - Structures
//
// Name: Robert Liszka
//
// Class: C Programming, Spring. 2025
//
// Date: March 9, 2025
//
// Description: Program which determines overtime and 
// gross pay for a set of employees with outputs sent 
// to standard output (the screen).
//
// Call by reference design
//
//********************************************************
 
// Define and Includes
 
#include <stdio.h>
 
// Define Constants
#define SIZE 5
#define STD_HOURS 40.0
#define OT_RATE 1.5
 
// Define a global structure to pass employee data between functions
// Note that the structure type is global, but you don't want a variable
// of that type to be global. Best to declare a variable of that type
// in a function like main or another function and pass as needed.
 
struct employee
{
    long clockNumber;
    float wageRate;
    float hours;
    float overtimeHrs;
    float grossPay;
};
 
// define prototypes here for each function except main
 
void getHours (struct employee employeeData[], int theSize );
void printHeader (void);
void printEmp (struct employee emp [ ], int theSize);
 
// TODO: add your function prototypes here
 
void calcOT (struct employee employeeData [],
int theSize);
void calcGross (struct employee employeeData [],
int theSize);
 
int main ()
{
    // Set up a local variable and initialize the clock and wages of my employees
    struct employee employeeData [SIZE] = {
        { 98401, 10.60 },
        { 526488, 9.75 },
        { 765349, 10.50 },
        { 34645, 12.25 },
        { 127615, 8.35 }
    };
 
    // Call function needed to read hours
    getHours (employeeData, SIZE);
 
    // TODO: Call functions calculate ot hours and gross pay
	calcOT (employeeData, SIZE);
	calcGross (employeeData, SIZE);
    // TODO: Call function to print the table column headers
 
    // Print a table header
    printHeader();
 
    // Function call to output results to the screen in table format
    printEmp (employeeData, SIZE);
 
    return(0); // success
 
} // main
 
//**************************************************************
// Function: getHours 
// 
// Purpose: Obtains input from user, the number of hours worked 
// per employee and stores the result in an array of structures
// that is passed back to the calling function by reference. 
// 
// Parameters:
// 
//     employeeData - an array of structures containing Employees
//     theSize - number of employees to process
//
// Returns: Nothing (void)
//  
//**************************************************************
 
void getHours (struct employee employeeData[], int theSize ) 
{
 
    int i; // loop and array index
 
    // read hours in for each employee
    for (i = 0; i < theSize ; ++i)
    {
        printf("\nEnter hours worked by emp # %06li: ",
                employeeData[i].clockNumber);
        scanf ("%f", &employeeData[i].hours);
    } // for
 
} // getHours
 
//**************************************************************
// Function: printHeader
// 
// Purpose: Prints the initial table header information.
// 
// Parameters: none
// 
// Returns: void
//  
//**************************************************************
 
void printHeader (void) 
{ 
 
    printf ("\n\n*** Pay Calculator ***\n");
 
    // print the table header
    printf("\nClock# Wage  Hours  OT      Gross\n");
    printf("------------------------------------------------\n");
 
} // printHeader
 
// ********************************************************************
// Function: printEmp
//
// Purpose: Outputs to screen in a table format the following
// information about an employee: Clock, Wage,
// Hours, Overtime Hours, and Gross Pay.
//
// Parameters:
//
//     employeeData - an array of structures containing Employees
//     theSize - number of employees to process
//
// Returns: Nothing (void)
//
// *********************************************************************
 
void printEmp ( struct employee employeeData[], int theSize )
{
    int i; // loop and array index
 
    // print information about each employee
    for (i = 0; i < theSize ; ++i)
    {
        printf("\n %06li %5.2f %4.1f %4.1f %8.2f",
        employeeData[i].clockNumber, employeeData[i].wageRate, employeeData[i].hours,
        employeeData[i].overtimeHrs, employeeData[i].grossPay);
 
    } /* for */
 
} // printEmp
 
// TODO: add your functions here
 
// Header
void calcOT (struct employee employeeData [],
int theSize)
{
	int i;
 
	for (i=0; I < SIZE; ++i)
{
// TODO: Add missing code
 
float overtimeHrs;
 
	overtimeHrs = hours - STD_WORK_WEEK;
 
	return (overtimeHrs);
 
} // for
 
}//calcOT
 
 
//Header
void calcGross (struct employee employeeData [],
int theSize)
{
 
	int i; // loop and array index
	float normalPay; // normal pay earned
	float overtimePay
 
	for (i=0; I < theSize; ++i)
{
// TODO: Add missing code
if (hours > STD_WORK_WEEK) 
	{
		// calculate overtime hours
		overtimeHrs = hours - STD_WORK_WEEK;
 
		// calculate normal pay
		normalPay = STD_WORK_WEEK * wageRate;
 
		// calculate overtime pay
		overtimePay = overtimeHrs * wageRate * OVERTIME_RATE;
 
		}	
	else
	{
		//they have no overtime hours
		overtimeHrs = 0;
		overtimePay = 0;
 
		// calculate normal pay
		normalPay = hours * wageRate;
 
		}// for if
 
 
	grossPay = normalPay + overtimePay;		
 
 
	return(grossPay);
} // for
 
 
}//calcGross

prog.c: In function ‘calcOT’:
prog.c:176:12: error: ‘I’ undeclared (first use in this function)
  for (i=0; I < SIZE; ++i)
            ^
prog.c:176:12: note: each undeclared identifier is reported only once for each function it appears in
prog.c:182:16: error: ‘hours’ undeclared (first use in this function)
  overtimeHrs = hours - STD_WORK_WEEK;
                ^~~~~
prog.c:182:24: error: ‘STD_WORK_WEEK’ undeclared (first use in this function)
  overtimeHrs = hours - STD_WORK_WEEK;
                        ^~~~~~~~~~~~~
prog.c:184:9: warning: ‘return’ with a value, in function returning void
  return (overtimeHrs);
         ^
prog.c:171:6: note: declared here
 void calcOT (struct employee employeeData [],
      ^~~~~~
prog.c: In function ‘calcGross’:
prog.c:200:2: error: expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘__attribute__’ before ‘for’
  for (i=0; I < theSize; ++i)
  ^~~
prog.c:200:12: error: ‘I’ undeclared (first use in this function)
  for (i=0; I < theSize; ++i)
            ^
prog.c:203:5: error: ‘hours’ undeclared (first use in this function)
 if (hours > STD_WORK_WEEK)
     ^~~~~
prog.c:203:13: error: ‘STD_WORK_WEEK’ undeclared (first use in this function)
 if (hours > STD_WORK_WEEK)
             ^~~~~~~~~~~~~
prog.c:206:3: error: ‘overtimeHrs’ undeclared (first use in this function)
   overtimeHrs = hours - STD_WORK_WEEK;
   ^~~~~~~~~~~
prog.c:209:31: error: ‘wageRate’ undeclared (first use in this function)
   normalPay = STD_WORK_WEEK * wageRate;
                               ^~~~~~~~
prog.c:212:3: error: ‘overtimePay’ undeclared (first use in this function)
   overtimePay = overtimeHrs * wageRate * OVERTIME_RATE;
   ^~~~~~~~~~~
prog.c:212:42: error: ‘OVERTIME_RATE’ undeclared (first use in this function); did you mean ‘OT_RATE’?
   overtimePay = overtimeHrs * wageRate * OVERTIME_RATE;
                                          ^~~~~~~~~~~~~
                                          OT_RATE
prog.c:227:2: error: ‘grossPay’ undeclared (first use in this function)
  grossPay = normalPay + overtimePay;
  ^~~~~~~~
prog.c:230:8: warning: ‘return’ with a value, in function returning void
  return(grossPay);
        ^
prog.c:192:6: note: declared here
 void calcGross (struct employee employeeData [],
      ^~~~~~~~~
prog.c: In function ‘getHours’:
prog.c:110:9: warning: ignoring return value of ‘scanf’, declared with attribute warn_unused_result [-Wunused-result]
         scanf ("%f", &employeeData[i].hours);
         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Standard output is empty