Key Value Pair implementation C

Question

I have a .txt file that stores student names along with two of their best marks. If a student for some reason, i.e. dropping out of course, fails to pass a course, then no marks are recorded.

My file looks like this

Samuel= 90.5, 95.9
Bill= 25.2, 45.3
Tim
Anthony= 99.9, 12.5
Mark
Rob

Basically, Tim, Mark and Rob failed the course and hence their marks are not stored. Also to differentiate between a failed mark and a pass mark, I have used the = symbol. Basically, I want to store all the names into memory alongside their associated values.

This is my implementation, however it is flawed in the sense that I have declared a double *marks[2] array to store all six marks, when clearly it will only store 3. I am having trouble storing the values into the double array.

This is my code...

istream& operator>> (istream& is, Students& student)
{
    student.names = new char*[6];
    for (int i=0; i<10; i++)
    {
     student.names[i] = new char[256];
     student.marks[i] = new double[2];
     is.getline(student.names[i], sizeof(student.names));

     for (int j=0; j < 256; j++)
     {
        if((student.names[i][j] == '='))
        {
            int newPos = j + 1;
            for (int k = newPos; k < 256; k++)
            {
                student.names[i][k - newPos] = student.names[k];
            }   
         }
      }
   }
}

How can I go about storing the values of the students with the valid marks? Please, no use of vectors or stringstreams, just pure C/C++ char arrays

Answer 1

You have a few options, you could use a struct like so

struct Record {
    std::string name;
    double marks[2];
};

And then stick that into something like std::vector<Record> or an array of them like

Records *r = new Records[1000];

You could also keep three different arrays (either automatically allocated or dynamically allocated or even std::vector), one to hold the name, two to hold the marks.

In each case you would just indicate a fail by some thing like the marks being zero.

Also, you can use

std::string name;
double first, second;
std::cin >> name;
if (name[name.size() - 1] == '=')
    std::cin >> first >> second;

And this will parse the input like you want it to for a single line. Once you've done that you can wrap the whole thing in a loop while sticking the values you get into some sort of data structure that I already described.

Hope that gives you a few ideas on where to go!

Answer 2

Here's a strategy:

First of all you need to implement a struct to hold the key-value pair, I suggest the following:

struct Student {
    char name[30];
    double marks[2];
};

Note that you can give the dimension of the char array inside the struct if you know that the length will never be higher. (which is given here)

Now what you need is to know how many lines are in your ifstream, you could make a loop of is.getline() calls to get there. (don't forget to call is.clear() and is.seekg(0) when finished, to be at the beginning for the real loop)

When you know how many lines are in your ifstream you can use dynamically cast the Array of your struct with the actual length of your file:

Student * students = new Student[lineCount]; // line count of is

As you can see, there's no need to have a std::vector to hold the values. Consider that the getline() loop may be an overkill just to get the line count, alternatively you could give a length to Students at compile-time by making an array with a length that will never be overpassed. (e.g. Student students[128];)

Now you need to parse the lines, i'd suggest you make a loop like the following (line by line):

// int parseLine ( char* line, char* name, double* marks ) { ...   
bool hasMarks=false;
int iLine=0; // Line pos iterator
int iName=0; // Name pos iterator
char mk1Str[4]; // String buffer, Mark 1
char mk2Str[4]; // String buffer, Mark 2

while(line[iLine]!='\0')
{
    if(line[iLine]=='=')
    {
        hasMarks=true;
        name[iLine]='\0';

        for(int iMark=0;iMark<4;iMark++)
        {
            mk1Str[iMark]=line[iLine+iMark+2];
            mk2Str[iMark]=line[iLine+iMark+8];
            // ^^ You can harcode the offsets (2,8) since they don't change 
        }
        break;
    }
    name[iName++]=line[iLine]; 
    iLine++;
}

Now what you need is to parse the marks to double values, for this you could use the atof() function that works with char*. The bool hasMarks helps you know if a student has defined marks, if not, you could define dummy values like -1 for the mark fields of your struct.

I think this works quite well for your case...