C - Build dynamically allocated array of pointers to structures filled with input from file

Question

I need to build an array of pointers to dynamically allocated structures (DBrecord) and fill that array with input from another file. Not sure how to approach this.

The data file will have the number of entries first, followed by entries in a specific order.

numOfEntries

lastName firstName studentID year gpa expGradYear

example:

1

Doe John 12345678 senior 3.14159 2015

Here's the code I have so far:

class.h

typedef enum {firstYear, sophomore, junior, senior, grad} class;

main.c

#include 
#include 
#include "class.h"

int main(){

//DBrecord is name for structure
struct DBrecord{
int DBrecordID;     //ID for each entry, range 0-319
char *last;         //student last name
char *first;        //student first name
char studentID[8];  //student ID
int age;            //student age
class year;         //year in school
float gpa;          //GPA
int expGradYear;    //expected graduation year
};
int numEntries;     //total number of entries, first num in data file
struct DBrecord **ptrToDB;

//scan first int in data file and assign to numEntries
scanf("%d", &numEntries);

//allocate memory for structures, each is 36 bytes
*ptrToDB = malloc (sizeof(struct DBrecord) * numEntries);

//free allocated memory
free(ptrToDB);

//build an array of pointers to dynamically allocated structures
//fill that array with input from data file

//build 7 arrays of pointers to DBrecords, one for each field except DB ID
//sort each a different way
//note the 7 arrays are pointers, no copying

//print each of the 7 sorted arrays

return 0;
}

Miroslav Mares · Accepted Answer

I can give you some snippets on how to look at this problem.

First - I would avoid using class name for any variable, because in many object-oriented programming languages (including C++) it is a keyword and can't be a name of variable.

Structure DBrecord

It might be a good idea to use typedef. Then you could declare a struct variable without using "struct DBrecord", just "DBrecord". But that's optional. This is how it would look:

typedef struct {
   int DBrecordID; // ID for each entry
   char *lastName;
   char *firstName;
   char studentID[8];
   ...
} DBrecord;

Loading from file

In this homework you have the number of records at the beginning of the file, so you don't need to take "extra" care about it. Just load it.

Let's assume the file is like this:

2
Doe John 12345678 senior 3.14159 2015
Carl Boss 32315484 junior 2.71 2013

Therefore the first thing you do with your file is to open it.

Portable way of working with files is by using FILE pointer. Let me show it (stdio.h must be included):

FILE *filePtr; // Define pointer to file
if((filePtr = fopen("records.txt", "r")) == NULL) // If couldn't open the file
{
   printf("Error: Couldn't open records.txt file.
"); // Printf error message
   exit(1);  // Exit the program
}

Then you can read from your file by line using fgets() to read by lines or fgetc() to read by characters. This is how you can read number of records (remember that it's on the first line and we've just opened the file - we are at the beginning of the file):

char buffer[100]; // Define the buffer
fgets(buffer, 100 /* size of buffer */, filePtr);

Now buffer contains the first line (without character) - number of records. Continue with converting the num's characters into integer (here stdlib.h also has to be included):

int numOfRecords = atoi(buffer);

Allocating enough DBrecords

Now you know the number of records, you can allocate enough space for them. We will use array of pointers.

DBrecord **recs;
recs = (DBrecord **) malloc(sizeof(DBrecord *) * numOfRecords);

Now we have created array of pointers, so now we need to allocate every individual pointer as a DBrecord. Using cycle:

int i;
for(i = 0; i < numOfRecords; i++)
{
   recs[i] = (DBRecord *) malloc(sizeof(DBrecord));
}

Now you can acces array elements (= individual records) like this:

recs[0]->lastname /* two possibilities */
*(recs[0]).lastname

an so on.

Filling array with values from file

Now you know everything to get the homework done. This way you fill the array:

int i;
for(i = 0; i < numOfRecords; i++)
{
   // Content of cycle reads one line of a file and parses the values into recs[i]->type...
   /* I give you small advice - you can use fgetc(filePtr); to obtain character by character from the file. As a 'deliminer' character you use space, when you hit newline, then the for cycle continues.
   You know the order of stored values in the file, so it shouldn't be hard for you.
   If you don't get it, let me now in comments */
}

Is it somehow clearer now?

EDIT: File name as main's argument

There are usually two ways of 'passing' arguments (values) to a program. They are:

./program < records.txt   // Here the file's name is passed to program on stdin
./program records.txt    // Here the file's name is passed as value in `argv`.

If you can choose, I strongly recommend you the second one. Therefore you need to have main defined as this:

int main(int argc, char *argv[])  // this is important!
{
   // code

   return 0;
}

argc is integer which says, how much arguments were passed to the program. argv is array storing them. Remember, that the first argument is name of the program. Therefore if you need to check for it, do it:

if(argc != 2)
{
  printf("Number of arguments is invalid
");
  exit(1); // exit program
}

Then you only put argv[1] into fopen function, instead of the string "records.txt".

EDIT 2: Reading file's name from stdin

Another approach must be done, if the name of the records file is passed to the program via ./program < records.txt, which means that "records.txt" (without quotes) will be passed (redirected) to program's standard input.

Therefore to handle that, you can do this:

char filename[50]; // buffer for file's name
scanf("%s", &filename); // reads standard input into 'filename' string until white character appears (new line, blank, tabulator).

Then you have your desired file's name in filename string.