Implementation of Dynamic memory allocation in files in C program

Question

I want the program to read the details of n employees from the file and store the Salary details of n employees to an array which is dynamically allocated and then print the average salary.

The below program gets the data from the user and stores it in a file.

#include <stdio.h>
#include <stdlib.h>
 
typedef struct
{
    char name[10];
    char nameEr[10];
    int salaryannual;
    char desig[10];
 
}Employee;
 
void main(int argc, char *argv[])
{
    int i,n=0,*ptr,sum=0;
    n=atoi(argv[1]);
    printf("The no.of employee records to be created are: %d\n",n);
    
    FILE *fp;
    
    if((fp=fopen("employee.txt","w"))==NULL) 
    {
      printf("File could not be opened\n");
    } 
    
 
    Employee employees[n];
 
    printf("Enter %d Employee Details: \n \n",n);
    
    for(i=0; i<n; i++)
    {
 
        printf("Employee %d: \n",i+1);
        printf("Employee name: ");
        scanf("%s",employees[i].name);
        printf("Employer name: ");
        scanf("%s",employees[i].nameEr);
        printf("Employee designation: ");
        scanf("%s",employees[i].desig);
        printf("Employee annual salary: ");
        scanf("%d",&employees[i].salaryannual);
        
 
        printf("\n");
    }
 
    for(i=0;i<n;i++)
    {
      fprintf(fp,"%s\n",employees[i].name);
      fprintf(fp,"%s\n",employees[i].nameEr);
      fprintf(fp,"%s\n",employees[i].desig);
      fprintf(fp,"%d\n",employees[i].salaryannual);
    }

    fclose(fp);
 
    for(i=0;i<n;i++)
    {
 
        printf("Employee name \t: ");
        printf("%s \n",employees[i].name);
 
        printf("Employer name \t: ");
        printf("%s \n",employees[i].nameEr);
        
        printf("Employee designation \t: ");
        printf("%s \n",employees[i].desig);
 
        printf("Employee annual salary: ");
        printf("%d \n",employees[i].salaryannual);
        
 
        printf("\n");
    }

How do I proceed further from this code. Please help me.

Hint: if the file could not be opened printf("File could not be opened\n"); is not enough — Jabberwocky
– Jabberwocky, Commented Jun 19, 2021 at 6:44

Jardel Lucca · Accepted Answer · 2021-06-19 06:38:03Z

There are certainly many approaches to solve this.
I think of one of the simplest is:

Get the employee count by opening the file for reading and counting the number of lines. The employee count will be the number of lines divided by four, since there are four lines for each employee. You typically make a function to do so:

int get_number_of_employees(int *number_of_employees)
{
    int ret = -1;

    int line_count = 0;

    FILE *fp = NULL;
    if ((fp = fopen("employee.txt", "r")) != NULL) {

        char line[64]  = {0,};
        while(fgets(line, sizeof(line), fp)) {

            line_count++;
        }

        *number_of_employees = line_count / 4;
        ret = 0;

        fclose(fp);
    }

    return ret;
}

Allocate memory for your buffer using the number of employees you got with the function above:

int salaries_array[employees_count];

Create a function fo fill in the array you just created. This will require the program to open the file for reading again:

int get_employees_salaries(int salaries_array[], int employees_count)
{
    int ret = -1;

    int line_count = 0;

    FILE *fp = NULL;
    if ((fp = fopen("employee.txt", "r")) != NULL) {

        char line[64]  = {0,};
        while(fgets(line, sizeof(line), fp)) {

            line_count++;
            if ((line_count % 4) == 0) {

                int salary = atoi(line);
                salaries_array[(line_count / 4) - 1] = salary;
                ret = 0;
            }
        }

        fclose(fp);
    }

    return ret;
}

Now, create a function to get the average salary from the array:

int get_average_salary(int salaries_array[], int employees_count)
{
    int salaries_sum = 0;

    int i = 0;
    for (; i < employees_count; i++) {

        salaries_sum += salaries_array[i];
    }

    return salaries_sum / employees_count;
}

Putting it all together:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    char name[10];
    char nameEr[10];
    int salaryannual;
    char desig[10];

} Employee;

int get_number_of_employees(int *number_of_employees)
{
    int ret = -1;

    int line_count = 0;

    FILE *fp = NULL;
    if ((fp = fopen("employee.txt", "r")) != NULL) {

        char line[64]  = {0,};
        while(fgets(line, sizeof(line), fp)) {

            line_count++;
        }

        *number_of_employees = line_count / 4;
        ret = 0;

        fclose(fp);
    }

    return ret;
}

int get_employees_salaries(int salaries_array[], int employees_count)
{
    int ret = -1;

    int line_count = 0;

    FILE *fp = NULL;
    if ((fp = fopen("employee.txt", "r")) != NULL) {

        char line[64]  = {0,};
        while(fgets(line, sizeof(line), fp)) {

            line_count++;
            if ((line_count % 4) == 0) {

                int salary = atoi(line);
                salaries_array[(line_count / 4) - 1] = salary;
                ret = 0;
            }
        }

        fclose(fp);
    }

    return ret;
}

int get_average_salary(int salaries_array[], int employees_count)
{
    int salaries_sum = 0;
    int i = 0;
    for (; i < employees_count; i++) {

        salaries_sum += salaries_array[i];
    }
    return salaries_sum / employees_count;
}

void main (int argc, char *argv[])
{
    int employees_count = 0;
    if (get_number_of_employees(&employees_count) == 0) {

        int salaries_array[employees_count];
        if (get_employees_salaries(salaries_array, employees_count) == 0) {

            int average_salary = get_average_salary(salaries_array, employees_count);
            printf("Average salary = %d\n", average_salary);
        }
    }
}

Thank you for your answer! @JardelLucca. Really helpful. Got idea how to use function in this program.
Functions are great but in case they grow too much in size, it's a good idea to split them into smaller functions.

cup · Accepted Answer · 2021-06-19 07:27:43Z

1

In order to dynamically allocate, you first need to decide on the allocation scheme. Here are a couple of schemes:

increment by a fixed number every time
increment by a fixed percentage

Unlike @jardellucca's method, even though the file is not read twice, these schemes require a lot of reallocation.

/* Increment by fixed number */
int increment = 5;
int employee_count = 0;
int employee_max = increment;
Employee* employees = malloc(sizeof(Employee) * employee_max);

...
void Save(Employee* emp)
{
    /* check if there is enough space */
    if (employee_count == employee_max)
    {
         employee_max += increment;
         employees = realloc(employees, sizeof(Employee) * employee_max)
    }
    employees[employee_count] = *emp;
    ++employee_count;
}

If you have 1000 records, this method reallocs 200 times. An alternative is to increase by a percentage

int increment_pc = 150; /* 50% */
int employee_count = 0;
int employee_max = 10;
Employee* employees = malloc(sizeof(Employee) * employee_max);

...
void Save(Employee* emp)
{
    /* check if there is enough space */
    if (employee_count == employee_max)
    {
         employee_max = (employee_max * increment_pc) / 100;
         employees = realloc(employees, sizeof(Employee) * employee_max)
    }
    employees[employee_count] = *emp;
    ++employee_count;
}

Using this allocation scheme, 1000 employees takes 13 reallocations but there is some wastage. The last allocation will allocate 1234, which is 234 over. In the previous scheme, it will, at most be 4 over. This is just a space/time problem.

You can waste time reading the file twice. You could, for instance be reading the file across a slow network.
You can waste time reallocating lots of times and have a few left over
You can waste space reallocating fewer times. You may be on a system that is tight on memory so a scheme like this may not be feasible.

The scheme you choose will be dependant upon the environment and the constraints. As for average salary, you can do sum up on the fly as the records are being saved and then just compute the average at the end.

answered Jun 19, 2021 at 7:27

cup

8,5384 gold badges23 silver badges48 bronze badges

2 Comments

SachC Over a year ago

Thank you for your answer @cup. Will implement your concept in my program!

Jardel Lucca Over a year ago

This is a great analysis and summary of the key points in tackling the problem. I didn't even think about possible outcomes from allocating memory in chunks. Only a good/experienced programmer would go to that level straightforward. Another point in my code (and in the OP's code as well) is the fact the memory with unknown size is allocated in tha stack. For any real life application this should be reviewed!

Collectives™ on Stack Overflow

Implementation of Dynamic memory allocation in files in C program

2 Answers 2

2 Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related