Segmentation fault (core dumped) after program has ran

I've ran the code in both Windows and Unix. When I ran the program in Unix I got "Segmentation fault (core dumped)". After googling this I've read that it could be a possibility of access an memory location which I don't have access to.

However, the point where it crashes is here:
1
2
3
4
5
6
printTotals(reportFile, EmployeeData, MAXEMPLOYEES);//call 3.8.1
	printAverages(reportFile, MAXEMPLOYEES, EmployeeData);//call 3.8.2
	fclose(reportFile);// Close file
	fflush(stdin);
	getchar();
	return 0;


It prints the totals and averages, closes the file successfully but when I hit enter, I run into the error (when it executes return 0).

I'm stuck on this homework and would really like some insight because this is bugging me. Thanks!
P.S I'm new to the forums and I've noticed that my code is very long. So I split it into 2 posts. Sorry =\

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef short BOOLEAN;
typedef char STR15[15+1];
typedef char STR10[10+1];
typedef struct PayRecord
{
	STR15 LastName;
	STR10 FirstName;
	float hours, payrate, deferred, gross, fedtax, statetax, ssitax, net;
	float reghrs, ovthrs;
	float totreg, totovt, totrate, totgross, totfed, totstate, totssi, totdefr, totnet;
} PayRecord;

#define FEDTAXRATE 0.15
#define STATETAXRATE 0.07
#define SSITAXRATE 0.0775
#define MAXEMPLOYEES 6
#define TRUE 1
#define FALSE 0

#define HEADLINE1       "Employee         Pay    Reg Hrs  Gross    Fed    SSI    Net\n"
#define HEADLINE2       "Name             Rate   Ovt Hrs  Pay     State   Defr   Pay\n"
#define HEADLINE3       "=========        ====== ======= ======= ======= ====== =======\n"
#define EMPLOYEEREPORT  "%-16s %5.2f    %5.2f %7.2f  %6.2f %6.2f %7.2f\n"
#define EMPLOYEEREPORT2 "                          %5.2f          %6.2f %6.2f\n\n"
#define BREAK           "==============================================================\n"
#define TOTALS1         "Totals           %5.2f   %6.2f %6.2f  %6.2f %6.2f %7.2f\n"
#define TOTALS2         "                         %6.2f           %5.2f %6.2f\n\n"
#define AVERAGES1       "Averages         %5.2f   %6.2f  %5.2f  %6.2f %6.2f %7.2f\n"
#define AVERAGES2       "                         %6.2f           %5.2f %6.2f\n\n"

#define BLANK	"*							   *\n"
#define BORDER  "************************************************************\n"
#define HEADER  "*				Check No %3d		   *\n"
#define HEADER2 "*   Sabre Corporation					   *\n"
#define HEADER3 "*   15790 West Henness lane				   *\n"
#define HEADER4 "*   New Corio, New Mexico 65790				   *\n"
#define HEADER5 "*   Pay to the Order of					   *\n"
#define HEADER6 "*   %-16s					   *\n"
#define HEADER7 "*   The Sum Nine Hundred Ninety-Nine and XX/100 Dollars    *\n"
#define HEADER8 "*   Reference: %-16s				   *\n"

#define STUB 	"*   Check No %3d					   *\n"
#define STUB2	"*   %-16s	   Reg Pay		Fed Tax	   *\n"
#define STUB3	"*   Address		   Ovt Pay		State Tax  *\n"
#define STUB4	"*   City, State		   Gross Pay		SSI Tax    *\n"
#define STUB5	"*   Zip			   Net Pay		Tax Total  *\n"

void PrintHeadings(FILE *reportFile)
{
	fprintf(reportFile,HEADLINE1);
	fprintf(reportFile,HEADLINE2);
	fprintf(reportFile,HEADLINE3);
}
void InitAccumulators(PayRecord EmployeeData[], int maxemployees)
{
	EmployeeData[MAXEMPLOYEES].totreg = 0;
	EmployeeData[MAXEMPLOYEES].totovt = 0;
	EmployeeData[MAXEMPLOYEES].totrate = 0;
	EmployeeData[MAXEMPLOYEES].totgross = 0;
	EmployeeData[MAXEMPLOYEES].totfed = 0;
	EmployeeData[MAXEMPLOYEES].totstate = 0;
	EmployeeData[MAXEMPLOYEES].totssi = 0;
	EmployeeData[MAXEMPLOYEES].totdefr = 0;
	EmployeeData[MAXEMPLOYEES].totnet = 0;
}
void InputEmployeeData(PayRecord EmployeeData[], int count)// 3.3
{
	printf("Please enter your first and last name: ");
	scanf("%s%s", EmployeeData[count].FirstName, EmployeeData[count].LastName);

	printf("Please enter hours, payrate, and deferred amount: ");
	scanf("%f%f%f", &EmployeeData[count].payrate, &EmployeeData[count].hours, &EmployeeData[count].deferred);
	printf("\n");
}
void QSortEmployee(PayRecord EmployeeData[], int start, int finish)
{
	int left = start,
		right = finish;
	char * pivot = EmployeeData[(start+finish)/2].LastName;

	while (left < right)
	{
		while ((strcmp(EmployeeData[left].LastName,pivot) < 0) && (left < right))
		{
			left++;
		}
		while ((strcmp(EmployeeData[right].LastName,pivot) > 0) && (right > left))
		{
			right--;
		}
		if (left <= right)
		{
			PayRecord tempEmployee = EmployeeData[left];
			EmployeeData[left] = EmployeeData[right];
			EmployeeData[right] = tempEmployee;
			left++;
			right--;
		}
	}
	if (start < finish)
	{
		QSortEmployee(EmployeeData, start, right);
	}
	if (left < finish)
	{
		QSortEmployee(EmployeeData, left, finish);
	}
}
float CalculateGross(PayRecord EmployeeData[], int count) // 3.4
{
   return (EmployeeData[count].hours <= 40) ? EmployeeData[count].hours * EmployeeData[count].payrate :
   						  EmployeeData[count].payrate * 40 + (EmployeeData[count].hours-40) * 1.5 * EmployeeData[count].payrate;
}

void CalculateHours(PayRecord EmployeeData[], int count)
{
	if(EmployeeData[count].hours <= 40)
	{
		EmployeeData[count].reghrs = EmployeeData[count].hours;
		EmployeeData[count].ovthrs = 0;
	}
	else
	{
		EmployeeData[count].reghrs = 40;
		EmployeeData[count].ovthrs = (EmployeeData[count].hours - 40);
	}
}
float CalculateNet(PayRecord EmployeeData[], int count)
{
	return EmployeeData[count].gross - (EmployeeData[count].fedtax + EmployeeData[count].statetax + EmployeeData[count].ssitax + EmployeeData[count].deferred);
}
void AddAccumulators(PayRecord EmployeeData[], int count, int maxemployees)
{
	EmployeeData[MAXEMPLOYEES].totreg = EmployeeData[MAXEMPLOYEES].totreg + EmployeeData[count].reghrs;
	EmployeeData[MAXEMPLOYEES].totovt = EmployeeData[MAXEMPLOYEES].totovt + EmployeeData[count].ovthrs;
	EmployeeData[MAXEMPLOYEES].totrate = EmployeeData[MAXEMPLOYEES].totrate + EmployeeData[count].payrate;
	EmployeeData[MAXEMPLOYEES].totgross = EmployeeData[MAXEMPLOYEES].totgross + EmployeeData[count].gross;
	EmployeeData[MAXEMPLOYEES].totfed = EmployeeData[MAXEMPLOYEES].totfed + EmployeeData[count].fedtax;
	EmployeeData[MAXEMPLOYEES].totstate = EmployeeData[MAXEMPLOYEES].totstate + EmployeeData[count].statetax;
	EmployeeData[MAXEMPLOYEES].totssi = EmployeeData[MAXEMPLOYEES].totssi + EmployeeData[count].ssitax;
	EmployeeData[MAXEMPLOYEES].totdefr = EmployeeData[MAXEMPLOYEES].totdefr + EmployeeData[count].deferred;
	EmployeeData[MAXEMPLOYEES].totnet = EmployeeData[MAXEMPLOYEES].totnet + EmployeeData[count].net;
}
Last edited on
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
void showReport(FILE *reportFile, char *FullName, PayRecord EmployeeData[], int count) //3.8
{
	printf(HEADLINE1);
	printf(HEADLINE2);
	printf(HEADLINE3);
	printf(EMPLOYEEREPORT, FullName,EmployeeData[count].payrate, EmployeeData[count].reghrs, EmployeeData[count].gross, EmployeeData[count].fedtax, EmployeeData[count].ssitax, EmployeeData[count].net);
	printf(EMPLOYEEREPORT2, EmployeeData[count].ovthrs, EmployeeData[count].statetax, EmployeeData[count].deferred);
	fprintf(reportFile,EMPLOYEEREPORT, FullName, EmployeeData[count].payrate, EmployeeData[count].reghrs, EmployeeData[count].gross, EmployeeData[count].fedtax, EmployeeData[count].ssitax, EmployeeData[count].net);
	fprintf(reportFile,EMPLOYEEREPORT2, EmployeeData[count].ovthrs, EmployeeData[count].statetax, EmployeeData[count].deferred);
}
void printTotals(FILE *reportFile, PayRecord EmployeeData[], int maxemployees)
{
	printf(BREAK);
	printf(TOTALS1, EmployeeData[MAXEMPLOYEES].totrate, EmployeeData[MAXEMPLOYEES].totreg, EmployeeData[MAXEMPLOYEES].totgross, EmployeeData[MAXEMPLOYEES].totfed, EmployeeData[MAXEMPLOYEES].totssi, EmployeeData[MAXEMPLOYEES].totnet);
	printf(TOTALS2, EmployeeData[MAXEMPLOYEES].totovt, EmployeeData[MAXEMPLOYEES].totstate, EmployeeData[MAXEMPLOYEES].totdefr);
	fprintf(reportFile,BREAK);
	fprintf(reportFile,TOTALS1, EmployeeData[MAXEMPLOYEES].totrate, EmployeeData[MAXEMPLOYEES].totreg, EmployeeData[MAXEMPLOYEES].totgross, EmployeeData[MAXEMPLOYEES].totfed, EmployeeData[MAXEMPLOYEES].totssi, EmployeeData[MAXEMPLOYEES].totnet);
	fprintf(reportFile,TOTALS2, EmployeeData[MAXEMPLOYEES].totovt, EmployeeData[MAXEMPLOYEES].totstate, EmployeeData[MAXEMPLOYEES].totdefr);
}
void printAverages(FILE *reportFile, int maxemployees, PayRecord EmployeeData[])
{
	printf(AVERAGES1, (EmployeeData[MAXEMPLOYEES].totrate/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totreg/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totgross/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totfed/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totssi/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totnet/(MAXEMPLOYEES-1)));
	printf(AVERAGES2, (EmployeeData[MAXEMPLOYEES].totovt/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totstate/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totdefr/(MAXEMPLOYEES-1)));
	fprintf(reportFile,AVERAGES1, (EmployeeData[MAXEMPLOYEES].totrate/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totreg/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totgross/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totfed/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totssi/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totnet/(MAXEMPLOYEES-1)));
	fprintf(reportFile,AVERAGES2, (EmployeeData[MAXEMPLOYEES].totovt/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totstate/(MAXEMPLOYEES-1)), (EmployeeData[MAXEMPLOYEES].totdefr/(MAXEMPLOYEES-1)));
}
float CalcFedtax(PayRecord EmployeeData[], int count) // 3.5.1
{
	return (EmployeeData[count].gross - EmployeeData[count].deferred)*FEDTAXRATE;
}
float CalcStatetax(PayRecord EmployeeData[], int count) // 3.5.2
{
	 return EmployeeData[count].fedtax * STATETAXRATE;
}
float CalcSSItax(PayRecord EmployeeData[], int count) // 3.5.3
{
	 return (EmployeeData[count].gross - EmployeeData[count].deferred)*SSITAXRATE;
}
void CalculateTaxes(PayRecord EmployeeData[], int count) //3.5
{
	EmployeeData[count].fedtax = CalcFedtax(EmployeeData, count); // call 3.5.1
	EmployeeData[count].statetax = CalcStatetax(EmployeeData, count); // call 3.5.2
	EmployeeData[count].ssitax = CalcSSItax(EmployeeData, count); // call 3.5.3
}
//====================

void printCheckHeader(PayRecord EmployeeData[], char *CheckName, int chkNo, char *refCode, int count)
{
	printf(BORDER);
	printf(HEADER, chkNo);
	printf(BLANK);
	printf(HEADER2);
	printf(HEADER3);
	printf(HEADER4);
	printf(BLANK);
	printf(BLANK);
	printf(HEADER5);
	printf(BLANK);
	printf(HEADER6, CheckName);
	printf(BLANK);
	printf(HEADER7);
	printf(BLANK);
	printf(BLANK);
	printf(HEADER8, refCode);
	printf(BLANK);
	printf(BLANK);
	printf(BORDER);
}
void printCheckStub(PayRecord EmployeeData[], char *CheckName, int chkNo, int count)
{
	printf(STUB, chkNo);
	printf(BLANK);
	printf(STUB2, CheckName);
	printf(STUB3);
	printf(STUB4);
	printf(STUB5);
	printf(BLANK);
	printf(BLANK);
	printf(BORDER);
	printf("\n");
}
BOOLEAN isVowel(char aChar)
{
	switch (toupper(aChar)) //<ctype.h>
	{
	  case 'A':
	  case 'E':
	  case 'I':
	  case 'O':
	  case 'U' : return TRUE;break;
	  default: return FALSE;
	}
}
char *generateRefCode(PayRecord EmployeeData[], int chkNo, int count)
{

	static char tempStr[15+10+1];
	char buffer[10+1];
	int i,j = 1;

	//This loop is used to clear the string everytime generateRefCode is called
	for ( i = 0; i < 31; i++)
	{
		tempStr[i] = 0;
	}
	//tempStr[0] = lastname[0]; // Needs to put the first letter into the temporary string.
	tempStr[0] = toupper(EmployeeData[count].LastName[0]);
	// This should be the first address that holds the first letter of the last name.
	// LOOP
	// Need to get through all the characters in the lastname.
	// Check if the letter is a vowl. If it is, add to the temporary string, else omit it.
	// ENDLOOP
	for (i=1; i < strlen(EmployeeData[count].LastName);i++)
	{
		if (!isVowel(EmployeeData[count].LastName[i]))
		{
			tempStr[j++] = toupper(EmployeeData[count].LastName[i]);
		}
	}

	sprintf(buffer, "%d", chkNo);
	//sprintf is used to make int chkNo into a string using a char buffer
	strcat(tempStr, buffer);
	tempStr[j+3] = 0;
	// add string terminator, adds the the current subscript+3 because we add
	// 3 numbers to the end of the string so that it adds the string terminator
	// to the end of the string.
	return tempStr;
}

int main(void)
{
	PayRecord EmployeeData[MAXEMPLOYEES];
	char FullName[15+10+1];
	char CheckName[15+10+1];
	char *refCode;
	int count;
	int chkNo = 100;
	FILE *reportFile; // Read as "reportFile is a pointer to a file"

	reportFile = fopen("./report.txt","wt");// open the file for "write-mode" access

	if (reportFile == NULL)// Test if file DID NOT open, exit.
	{
		printf(" report file open failed ...\n");
		fflush(stdin);
		exit(-30); //reqs <stdlib.h>
	}

	PrintHeadings(reportFile);//Call 3.1
	InitAccumulators(EmployeeData, MAXEMPLOYEES);//call 3.2
	for (count = 0; count < (MAXEMPLOYEES-1); count++)
	{
		InputEmployeeData(EmployeeData, count);
	}

	QSortEmployee(EmployeeData, 0, (MAXEMPLOYEES-2));

	for (count = 0; count < (MAXEMPLOYEES-1); count++)
	{
		strcpy(FullName, EmployeeData[count].LastName);
		strcat(FullName, ", ");
		strcat(FullName, EmployeeData[count].FirstName);
		EmployeeData[count].gross = CalculateGross(EmployeeData, count);// Call 3.4
		//CalculateHours() does not actually calculate any hours
		//It seperates the hours into regular hours and overtime hours
		CalculateHours(EmployeeData, count);// Call 3.4.1
		CalculateTaxes(EmployeeData, count); // call 3.5
		EmployeeData[count].net = CalculateNet(EmployeeData, count);//call 3.6
		AddAccumulators(EmployeeData, count, MAXEMPLOYEES);//call 3.7
		showReport(reportFile,FullName, EmployeeData, count);//call 3.8
	}

	for (count = 0; count < (MAXEMPLOYEES-1); count++)
	{
		refCode = generateRefCode(EmployeeData, chkNo, count);
		strcpy(CheckName, EmployeeData[count].FirstName);
		strcat(CheckName, " ");
		strcat(CheckName, EmployeeData[count].LastName);
		printCheckHeader(EmployeeData, CheckName, chkNo, refCode, count);
		printCheckStub(EmployeeData, CheckName, chkNo, count);
		chkNo++;
	}

	printTotals(reportFile, EmployeeData, MAXEMPLOYEES);//call 3.8.1
	printAverages(reportFile, MAXEMPLOYEES, EmployeeData);//call 3.8.2
	fclose(reportFile);// Close file
	fflush(stdin);
	getchar();
	return 0;]
the first problem is InitAccumulators:

you use MAXEMPLOYEES instead of maxemployees (which is out of bounds and causes a crash). You do that quite often. So I suggest that you move line 21 directly before line 133.

More so: you initialize only a single element (which is like I stated above out of bounds)
Thanks for the reply. I managed to find the workaround with your response.
Last edited on
Topic archived. No new replies allowed.