LtxdHI - Online C Compiler & Debugging Tool

//********************************************************
//
// Assignment 8 - Structures and Strings and Pointers
//
// Name: <replace with your name>
//
// Class: C Programming, <replace with Semester and Year>
//
// Date: <replace with the current date>
//
// Description: Program which determines overtime and
// gross pay for a set of employees with outputs sent
// to standard output (the screen).
//
// This assignment also adds the employee name, their tax state,
// and calculates the state tax, federal tax, and net pay.   It
// also calculates totals, averages, minimum, and maximum values.
//
// Array and Structure references are to be replaced with
// pointer references to speed up the processing of this code.
//
// Call by Reference design (using pointers)
//
//********************************************************

// necessary header files
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h> // for exit()

// define constants
#define SIZE 5
#define STD_HOURS 40.0
#define OT_RATE 1.5
#define MA_TAX_RATE 0.05
#define NH_TAX_RATE 0.0
#define VT_TAX_RATE 0.06
#define CA_TAX_RATE 0.07
#define DEFAULT_TAX_RATE 0.08
#define NAME_SIZE 20
#define TAX_STATE_SIZE 3
#define FED_TAX_RATE 0.25
#define FIRST_NAME_SIZE 10
#define LAST_NAME_SIZE 10

// Define a structure type to store an employee name
struct name
{
    char firstName[FIRST_NAME_SIZE];
    char lastName [LAST_NAME_SIZE];
};

// Define a structure type to pass employee data between functions
struct employee
{
    struct name empName;
    char taxState [TAX_STATE_SIZE];
    long int clockNumber;
    float wageRate;
    float hours;
    float overtimeHrs;
    float grossPay;
    float stateTax;
    float fedTax;
    float netPay;
};

// Function prototypes
void inputData(struct employee *empPtr);
void calculatePay(struct employee *empPtr);
void calculateTaxes(struct employee *empPtr);
void outputData(const struct employee *empPtr);
void calculateStats(const struct employee *emps, float *totalGrossPayPtr, float *avgGrossPayPtr,
                    float *minGrossPayPtr, float *maxGrossPayPtr);
void outputStats(float totalGrossPay, float avgGrossPay, float minGrossPay, float maxGrossPay);

int main()
{
    struct employee employees[SIZE];
    float totalGrossPay = 0.0, avgGrossPay = 0.0, minGrossPay = 0.0, maxGrossPay = 0.0;
    int i;

    // Loop to input data for each employee
    for (i = 0; i < SIZE; i++)
    {
        printf("--- Enter data for Employee %d ---\n", i + 1);
        inputData(&employees[i]);
        calculatePay(&employees[i]);
        calculateTaxes(&employees[i]);
    }

    // Output header
    printf("\n\n------------------------------------------------------------------------------------------------------------------\n");
    printf("| Name                 | Clock #   | Wage | Hours | OT Hrs | Gross Pay | State Tax | Fed Tax   | Net Pay   |\n");
    printf("------------------------------------------------------------------------------------------------------------------\n");

    // Loop to output data for each employee
    for (i = 0; i < SIZE; i++)
    {
        outputData(&employees[i]);
    }
    printf("------------------------------------------------------------------------------------------------------------------\n");

    // Calculate and output statistics
    calculateStats(employees, &totalGrossPay, &avgGrossPay, &minGrossPay, &maxGrossPay);
    outputStats(totalGrossPay, avgGrossPay, minGrossPay, maxGrossPay);

    return 0;
}

// Function to input employee data using pointers
void inputData(struct employee *empPtr)
{
    printf("Enter first name: ");
    scanf("%s", empPtr->empName.firstName);
    printf("Enter last name: ");
    scanf("%s", empPtr->empName.lastName);
    printf("Enter tax state (MA, NH, VT, CA, or Other): ");
    scanf("%s", empPtr->taxState);
    printf("Enter clock number: ");
    scanf("%ld", &empPtr->clockNumber);
    printf("Enter wage rate: ");
    scanf("%f", &empPtr->wageRate);
    printf("Enter hours worked: ");
    scanf("%f", &empPtr->hours);
}

// Function to calculate overtime hours and gross pay using pointers
void calculatePay(struct employee *empPtr)
{
    if (empPtr->hours > STD_HOURS)
    {
        empPtr->overtimeHrs = empPtr->hours - STD_HOURS;
        empPtr->grossPay = (STD_HOURS * empPtr->wageRate) +
                           (empPtr->overtimeHrs * empPtr->wageRate * OT_RATE);
    }
    else
    {
        empPtr->overtimeHrs = 0.0;
        empPtr->grossPay = empPtr->hours * empPtr->wageRate;
    }
}

// Function to calculate taxes using pointers and string comparison
void calculateTaxes(struct employee *empPtr)
{
    float stateTaxRate;

    // Convert state input to uppercase for comparison
    empPtr->taxState[0] = toupper(empPtr->taxState[0]);
    empPtr->taxState[1] = toupper(empPtr->taxState[1]);

    if (strcmp(empPtr->taxState, "MA") == 0)
    {
        stateTaxRate = MA_TAX_RATE;
    }
    else if (strcmp(empPtr->taxState, "NH") == 0)
    {
        stateTaxRate = NH_TAX_RATE;
    }
    else if (strcmp(empPtr->taxState, "VT") == 0)
    {
        stateTaxRate = VT_TAX_RATE;
    }
    else if (strcmp(empPtr->taxState, "CA") == 0)
    {
        stateTaxRate = CA_TAX_RATE;
    }
    else
    {
        stateTaxRate = DEFAULT_TAX_RATE;
    }

    empPtr->stateTax = empPtr->grossPay * stateTaxRate;
    empPtr->fedTax = empPtr->grossPay * FED_TAX_RATE;
    empPtr->netPay = empPtr->grossPay - empPtr->stateTax - empPtr->fedTax;
}

// Function to output employee data using pointers
void outputData(const struct employee *empPtr)
{
    char fullName[NAME_SIZE];
    sprintf(fullName, "%s %s", empPtr->empName.firstName, empPtr->empName.lastName);

    printf("| %-20s | %-9ld | %-4.2f | %-5.2f | %-6.2f | %-9.2f | %-9.2f | %-9.2f | %-9.2f |\n",
           fullName,
           empPtr->clockNumber,
           empPtr->wageRate,
           empPtr->hours,
           empPtr->overtimeHrs,
           empPtr->grossPay,
           empPtr->stateTax,
           empPtr->fedTax,
           empPtr->netPay);
}

// Function to calculate total, average, min, and max gross pay using pointers
void calculateStats(const struct employee *emps, float *totalGrossPayPtr, float *avgGrossPayPtr,
                    float *minGrossPayPtr, float *maxGrossPayPtr)
{
    int i;
    *totalGrossPayPtr = 0.0;
    *minGrossPayPtr = emps[0].grossPay; // Initialize min/max with the first employee's data
    *maxGrossPayPtr = emps[0].grossPay;

    for (i = 0; i < SIZE; i++)
    {
        *totalGrossPayPtr += emps[i].grossPay;

        if (emps[i].grossPay < *minGrossPayPtr)
        {
            *minGrossPayPtr = emps[i].grossPay;
        }

        if (emps[i].grossPay > *maxGrossPayPtr)
        {
            *maxGrossPayPtr = emps[i].grossPay;
        }
    }

    *avgGrossPayPtr = *totalGrossPayPtr / SIZE;
}

// Function to output statistics
void outputStats(float totalGrossPay, float avgGrossPay, float minGrossPay, float maxGrossPay)
{
    printf("\nPayroll Statistics:\n");
    printf("Total Gross Pay: $%.2f\n", totalGrossPay);
    printf("Average Gross Pay: $%.2f\n", avgGrossPay);
    printf("Minimum Gross Pay: $%.2f\n", minGrossPay);
    printf("Maximum Gross Pay: $%.2f\n", maxGrossPay);
}