fork(1) download 
  1. //********************************************************
  2. // Assignment 8 - Pointers & Structures
  3. // Name: Anthony Principe
  4. // Class: C Programming, Fall 2025
  5. // Date: November 2025
  6. //
  7. // Description:
  8. // Program calculates overtime, gross pay, state tax, federal tax,
  9. // net pay, totals, averages, min, and max values for a set of employees.
  10. // This version updates last week's Call-by-Value and array-based
  11. // approach to a Call-by-Reference design using pointers.
  12. //
  13. //********************************************************
  14.  
  15. #include <stdio.h>
  16. #include <string.h>
  17.  
  18. // define constants
  19. #define SIZE 5
  20. #define STD_HOURS 40.0
  21. #define OT_RATE 1.5
  22. #define MA_TAX_RATE 0.05
  23. #define NH_TAX_RATE 0.0
  24. #define VT_TAX_RATE 0.06
  25. #define CA_TAX_RATE 0.07
  26. #define DEFAULT_TAX_RATE 0.08
  27. #define FED_TAX_RATE 0.25
  28. #define FIRST_NAME_SIZE 10
  29. #define LAST_NAME_SIZE 10
  30. #define TAX_STATE_SIZE 3
  31.  
  32. // structure to hold employee name
  33. struct name {
  34.     char firstName[FIRST_NAME_SIZE];
  35.     char lastName[LAST_NAME_SIZE];
  36. };
  37.  
  38. // structure to hold employee info
  39. struct employee {
  40.     struct name empName;
  41.     char taxState[TAX_STATE_SIZE];
  42.     long int clockNumber;
  43.     float wageRate;
  44.     float hours;
  45.     float overtimeHrs;
  46.     float grossPay;
  47.     float stateTax;
  48.     float fedTax;
  49.     float netPay;
  50. };
  51.  
  52. // totals structure
  53. struct totals {
  54.     float total_wageRate;
  55.     float total_hours;
  56.     float total_overtimeHrs;
  57.     float total_grossPay;
  58.     float total_stateTax;
  59.     float total_fedTax;
  60.     float total_netPay;
  61. };
  62.  
  63. // min / max structure
  64. struct min_max {
  65.     float min_wageRate;
  66.     float min_hours;
  67.     float min_overtimeHrs;
  68.     float min_grossPay;
  69.     float min_stateTax;
  70.     float min_fedTax;
  71.     float min_netPay;
  72.     float max_wageRate;
  73.     float max_hours;
  74.     float max_overtimeHrs;
  75.     float max_grossPay;
  76.     float max_stateTax;
  77.     float max_fedTax;
  78.     float max_netPay;
  79. };
  80.  
  81. // function prototypes w/ pointers
  82. void getHours(struct employee *emp_ptr, int theSize);
  83. void calcOvertimeHrs(struct employee *emp_ptr, int theSize);
  84. void calcGrossPay(struct employee *emp_ptr, int theSize);
  85. void calcStateTax(struct employee *emp_ptr, int theSize);
  86. void calcFedTax(struct employee *emp_ptr, int theSize);
  87. void calcNetPay(struct employee *emp_ptr, int theSize);
  88. void calcEmployeeTotals(struct employee *emp_ptr, struct totals *emp_totals_ptr, int theSize);
  89. void calcEmployeeMinMax(struct employee *emp_ptr, struct min_max *emp_minMax_ptr, int theSize);
  90. void printHeader(void);
  91. void printEmp(struct employee *emp_ptr, int theSize);
  92. void printEmpStatistics(struct totals *emp_totals_ptr, struct min_max *emp_minMax_ptr, int theSize);
  93.  
  94. int main() 
  95. {
  96.     // employee array w/ initial values
  97.     struct employee employeeData[SIZE] = {
  98.         { {"Connie","Cobol"}, "MA", 98401, 10.60 },
  99.         { {"Mary", "Apl"}, "NH", 526488, 9.75 },
  100.         { {"Frank","Fortran"}, "VT", 765349, 10.50 },
  101.         { {"Jeff","Ada"}, "NY", 34645, 12.25 },
  102.         { {"Anton","Pascal"}, "CA", 127615, 8.35 }
  103.     };
  104.  
  105.     // totals and min/max init
  106.     struct totals employeeTotals = {0,0,0,0,0,0,0};
  107.     struct min_max employeeMinMax = {0,0,0,0,0,0,0,0,0,0,0,0,0};
  108.  
  109.     // get hours and do calculations
  110.     getHours(employeeData, SIZE);
  111.     calcOvertimeHrs(employeeData, SIZE);
  112.     calcGrossPay(employeeData, SIZE);
  113.     calcStateTax(employeeData, SIZE);
  114.     calcFedTax(employeeData, SIZE);
  115.     calcNetPay(employeeData, SIZE);
  116.  
  117.     calcEmployeeTotals(employeeData, &employeeTotals, SIZE);
  118.     calcEmployeeMinMax(employeeData, &employeeMinMax, SIZE);
  119.  
  120.     printHeader();
  121.     printEmp(employeeData, SIZE);
  122.  
  123.     printEmpStatistics(&employeeTotals, &employeeMinMax, SIZE);
  124.  
  125.     printf("\n\n");
  126.     return 0;
  127. }
  128.  
  129. //********************************************************
  130. // Function: getHours (Pointer Version)
  131. //********************************************************
  132. void getHours(struct employee *emp_ptr, int theSize)
  133. {
  134.     int i; // loop counter
  135.  
  136.     for (i = 0; i < theSize; ++i)
  137.     {
  138.         printf("\nEnter hours worked by emp # %06li: ", emp_ptr->clockNumber);
  139.         scanf("%f", &emp_ptr->hours);
  140.         ++emp_ptr; // move to next employee record
  141.     }
  142. }
  143.  
  144. //********************************************************
  145. // Function: calcOvertimeHrs (Pointer)
  146. //********************************************************
  147. void calcOvertimeHrs(struct employee *emp_ptr, int theSize)
  148. {
  149.     int i;
  150.     for (i = 0; i < theSize; ++i)
  151.     {
  152.         emp_ptr->overtimeHrs = (emp_ptr->hours > STD_HOURS) 
  153.                                 ? emp_ptr->hours - STD_HOURS : 0.0;
  154.         ++emp_ptr;
  155.     }
  156. }
  157.  
  158. //********************************************************
  159. // Function: calcGrossPay (Pointer)
  160. //********************************************************
  161. void calcGrossPay(struct employee *emp_ptr, int theSize)
  162. {
  163.     int i;
  164.     for (i = 0; i < theSize; ++i)
  165.     {
  166.         emp_ptr->grossPay = (emp_ptr->hours <= STD_HOURS)
  167.                             ? emp_ptr->hours * emp_ptr->wageRate
  168.                             : (STD_HOURS * emp_ptr->wageRate) + 
  169.                               (emp_ptr->overtimeHrs * emp_ptr->wageRate * OT_RATE);
  170.         ++emp_ptr;
  171.     }
  172. }
  173.  
  174. //********************************************************
  175. // Function: calcStateTax (Pointer)
  176. //********************************************************
  177. void calcStateTax(struct employee *emp_ptr, int theSize)
  178. {
  179.     int i;
  180.     for (i = 0; i < theSize; ++i)
  181.     {
  182.         if (strcmp(emp_ptr->taxState, "MA") == 0)
  183.             emp_ptr->stateTax = emp_ptr->grossPay * MA_TAX_RATE;
  184.         else if (strcmp(emp_ptr->taxState, "NH") == 0)
  185.             emp_ptr->stateTax = emp_ptr->grossPay * NH_TAX_RATE;
  186.         else if (strcmp(emp_ptr->taxState, "VT") == 0)
  187.             emp_ptr->stateTax = emp_ptr->grossPay * VT_TAX_RATE;
  188.         else if (strcmp(emp_ptr->taxState, "CA") == 0)
  189.             emp_ptr->stateTax = emp_ptr->grossPay * CA_TAX_RATE;
  190.         else
  191.             emp_ptr->stateTax = emp_ptr->grossPay * DEFAULT_TAX_RATE;
  192.  
  193.         ++emp_ptr;
  194.     }
  195. }
  196.  
  197. //********************************************************
  198. // Function: calcFedTax (Pointer)
  199. //********************************************************
  200. void calcFedTax(struct employee *emp_ptr, int theSize)
  201. {
  202.     int i;
  203.     for (i = 0; i < theSize; ++i)
  204.     {
  205.         emp_ptr->fedTax = emp_ptr->grossPay * FED_TAX_RATE;
  206.         ++emp_ptr;
  207.     }
  208. }
  209.  
  210. //********************************************************
  211. // Function: calcNetPay (Pointer)
  212. //********************************************************
  213. void calcNetPay(struct employee *emp_ptr, int theSize)
  214. {
  215.     int i;
  216.     for (i = 0; i < theSize; ++i)
  217.     {
  218.         emp_ptr->netPay = emp_ptr->grossPay - (emp_ptr->stateTax + emp_ptr->fedTax);
  219.         ++emp_ptr;
  220.     }
  221. }
  222.  
  223. //********************************************************
  224. // Function: calcEmployeeTotals (Given w/ pointer logic)
  225. //********************************************************
  226. void calcEmployeeTotals(struct employee *emp_ptr, struct totals *emp_totals_ptr, int theSize)
  227. {
  228.     int i;
  229.     for (i = 0; i < theSize; ++i)
  230.     {
  231.         emp_totals_ptr->total_wageRate += emp_ptr->wageRate;
  232.         emp_totals_ptr->total_hours += emp_ptr->hours;
  233.         emp_totals_ptr->total_overtimeHrs += emp_ptr->overtimeHrs;
  234.         emp_totals_ptr->total_grossPay += emp_ptr->grossPay;
  235.         emp_totals_ptr->total_stateTax += emp_ptr->stateTax;
  236.         emp_totals_ptr->total_fedTax += emp_ptr->fedTax;
  237.         emp_totals_ptr->total_netPay += emp_ptr->netPay;
  238.         ++emp_ptr;
  239.     }
  240. }
  241.  
  242. //********************************************************
  243. // Function: calcEmployeeMinMax (Pointer)
  244. //********************************************************
  245. void calcEmployeeMinMax(struct employee *emp_ptr, struct min_max *emp_minMax_ptr, int theSize)
  246. {
  247.     int i;
  248.  
  249.     // initialize min to first employee values
  250.     emp_minMax_ptr->min_wageRate = emp_ptr->wageRate;
  251.     emp_minMax_ptr->min_hours = emp_ptr->hours;
  252.     emp_minMax_ptr->min_overtimeHrs = emp_ptr->overtimeHrs;
  253.     emp_minMax_ptr->min_grossPay = emp_ptr->grossPay;
  254.     emp_minMax_ptr->min_stateTax = emp_ptr->stateTax;
  255.     emp_minMax_ptr->min_fedTax = emp_ptr->fedTax;
  256.     emp_minMax_ptr->min_netPay = emp_ptr->netPay;
  257.  
  258.     // initialize max
  259.     emp_minMax_ptr->max_wageRate = emp_ptr->wageRate;
  260.     emp_minMax_ptr->max_hours = emp_ptr->hours;
  261.     emp_minMax_ptr->max_overtimeHrs = emp_ptr->overtimeHrs;
  262.     emp_minMax_ptr->max_grossPay = emp_ptr->grossPay;
  263.     emp_minMax_ptr->max_stateTax = emp_ptr->stateTax;
  264.     emp_minMax_ptr->max_fedTax = emp_ptr->fedTax;
  265.     emp_minMax_ptr->max_netPay = emp_ptr->netPay;
  266.  
  267.     ++emp_ptr; // move to next employee
  268.  
  269.     for (i = 1; i < theSize; ++i)
  270.     {
  271.         if (emp_ptr->wageRate < emp_minMax_ptr->min_wageRate)
  272.             emp_minMax_ptr->min_wageRate = emp_ptr->wageRate;
  273.         if (emp_ptr->wageRate > emp_minMax_ptr->max_wageRate)
  274.             emp_minMax_ptr->max_wageRate = emp_ptr->wageRate;
  275.  
  276.         if (emp_ptr->hours < emp_minMax_ptr->min_hours)
  277.             emp_minMax_ptr->min_hours = emp_ptr->hours;
  278.         if (emp_ptr->hours > emp_minMax_ptr->max_hours)
  279.             emp_minMax_ptr->max_hours = emp_ptr->hours;
  280.  
  281.         if (emp_ptr->overtimeHrs < emp_minMax_ptr->min_overtimeHrs)
  282.             emp_minMax_ptr->min_overtimeHrs = emp_ptr->overtimeHrs;
  283.         if (emp_ptr->overtimeHrs > emp_minMax_ptr->max_overtimeHrs)
  284.             emp_minMax_ptr->max_overtimeHrs = emp_ptr->overtimeHrs;
  285.  
  286.         if (emp_ptr->grossPay < emp_minMax_ptr->min_grossPay)
  287.             emp_minMax_ptr->min_grossPay = emp_ptr->grossPay;
  288.         if (emp_ptr->grossPay > emp_minMax_ptr->max_grossPay)
  289.             emp_minMax_ptr->max_grossPay = emp_ptr->grossPay;
  290.  
  291.         if (emp_ptr->stateTax < emp_minMax_ptr->min_stateTax)
  292.             emp_minMax_ptr->min_stateTax = emp_ptr->stateTax;
  293.         if (emp_ptr->stateTax > emp_minMax_ptr->max_stateTax)
  294.             emp_minMax_ptr->max_stateTax = emp_ptr->stateTax;
  295.  
  296.         if (emp_ptr->fedTax < emp_minMax_ptr->min_fedTax)
  297.             emp_minMax_ptr->min_fedTax = emp_ptr->fedTax;
  298.         if (emp_ptr->fedTax > emp_minMax_ptr->max_fedTax)
  299.             emp_minMax_ptr->max_fedTax = emp_ptr->fedTax;
  300.  
  301.         if (emp_ptr->netPay < emp_minMax_ptr->min_netPay)
  302.             emp_minMax_ptr->min_netPay = emp_ptr->netPay;
  303.         if (emp_ptr->netPay > emp_minMax_ptr->max_netPay)
  304.             emp_minMax_ptr->max_netPay = emp_ptr->netPay;
  305.  
  306.         ++emp_ptr;
  307.     }
  308. }
  309.  
  310. //********************************************************
  311. // Function: printHeader
  312. //********************************************************
  313. void printHeader(void)
  314. {
  315.     printf("\n\n*** Pay Calculator ***\n\n");
  316.     printf("Name                State Clock#   Wage   Hours  OT     Gross    StateTax  FedTax   NetPay\n");
  317.     printf("--------------------------------------------------------------------------------------------\n");
  318. }
  319.  
  320. //********************************************************
  321. // Function: printEmp (Pointer)
  322. //********************************************************
  323. void printEmp(struct employee *emp_ptr, int theSize)
  324. {
  325.     int i;
  326.  
  327.     for (i = 0; i < theSize; ++i)
  328.     {
  329.         printf("%-10.10s %-10.10s %-2.2s %06li %6.2f %6.1f %6.1f %8.2f %9.2f %8.2f %8.2f\n",
  330.                emp_ptr->empName.firstName,
  331.                emp_ptr->empName.lastName,
  332.                emp_ptr->taxState,
  333.                emp_ptr->clockNumber,
  334.                emp_ptr->wageRate,
  335.                emp_ptr->hours,
  336.                emp_ptr->overtimeHrs,
  337.                emp_ptr->grossPay,
  338.                emp_ptr->stateTax,
  339.                emp_ptr->fedTax,
  340.                emp_ptr->netPay);
  341.  
  342.         ++emp_ptr;
  343.     }
  344. }
  345.  
  346. //********************************************************
  347. // Function: printEmpStatistics (Pointer)
  348. //********************************************************
  349. void printEmpStatistics(struct totals *emp_totals_ptr, struct min_max *emp_minMax_ptr, int theSize)
  350. {
  351.     printf("\n--------------------------------------------------------------------------------------------\n");
  352.     printf("TOTALS        %6.2f %6.1f %6.1f %8.2f %9.2f %8.2f %8.2f\n",
  353.            emp_totals_ptr->total_wageRate,
  354.            emp_totals_ptr->total_hours,
  355.            emp_totals_ptr->total_overtimeHrs,
  356.            emp_totals_ptr->total_grossPay,
  357.            emp_totals_ptr->total_stateTax,
  358.            emp_totals_ptr->total_fedTax,
  359.            emp_totals_ptr->total_netPay);
  360.  
  361.     printf("AVERAGES      %6.2f %6.1f %6.1f %8.2f %9.2f %8.2f %8.2f\n",
  362.            emp_totals_ptr->total_wageRate / theSize,
  363.            emp_totals_ptr->total_hours / theSize,
  364.            emp_totals_ptr->total_overtimeHrs / theSize,
  365.            emp_totals_ptr->total_grossPay / theSize,
  366.            emp_totals_ptr->total_stateTax / theSize,
  367.            emp_totals_ptr->total_fedTax / theSize,
  368.            emp_totals_ptr->total_netPay / theSize);
  369.  
  370.     printf("MINIMUMS      %6.2f %6.1f %6.1f %8.2f %9.2f %8.2f %8.2f\n",
  371.            emp_minMax_ptr->min_wageRate,
  372.            emp_minMax_ptr->min_hours,
  373.            emp_minMax_ptr->min_overtimeHrs,
  374.            emp_minMax_ptr->min_grossPay,
  375.            emp_minMax_ptr->min_stateTax,
  376.            emp_minMax_ptr->min_fedTax,
  377.            emp_minMax_ptr->min_netPay);
  378.  
  379.     printf("MAXIMUMS      %6.2f %6.1f %6.1f %8.2f %9.2f %8.2f %8.2f\n",
  380.            emp_minMax_ptr->max_wageRate,
  381.            emp_minMax_ptr->max_hours,
  382.            emp_minMax_ptr->max_overtimeHrs,
  383.            emp_minMax_ptr->max_grossPay,
  384.            emp_minMax_ptr->max_stateTax,
  385.            emp_minMax_ptr->max_fedTax,
  386.            emp_minMax_ptr->max_netPay);
  387. }
  388.  
Success #stdin #stdout 0.01s 5320KB
comments (?)
stdin 
 51.0   
 42.5
 37.0
 45.0
 40.0
stdout 
Enter hours worked by emp # 098401: 
Enter hours worked by emp # 526488: 
Enter hours worked by emp # 765349: 
Enter hours worked by emp # 034645: 
Enter hours worked by emp # 127615: 

*** Pay Calculator ***

Name                State Clock#   Wage   Hours  OT     Gross    StateTax  FedTax   NetPay
--------------------------------------------------------------------------------------------
Connie     Cobol      MA 098401  10.60   51.0   11.0   598.90     29.95   149.73   419.23
Mary       Apl        NH 526488   9.75   42.5    2.5   426.56      0.00   106.64   319.92
Frank      Fortran    VT 765349  10.50   37.0    0.0   388.50     23.31    97.12   268.07
Jeff       Ada        NY 034645  12.25   45.0    5.0   581.88     46.55   145.47   389.86
Anton      Pascal     CA 127615   8.35   40.0    0.0   334.00     23.38    83.50   227.12

--------------------------------------------------------------------------------------------
TOTALS         51.45  215.5   18.5  2329.84    123.18   582.46  1624.19
AVERAGES       10.29   43.1    3.7   465.97     24.64   116.49   324.84
MINIMUMS        8.35   37.0    0.0   334.00      0.00    83.50   227.12
MAXIMUMS       12.25   51.0   11.0   598.90     46.55   149.73   419.23
https://ideone.com/nydwse
language:
C (gcc 8.3)
created:
15 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!