structure dynamic allocation

Question

0.00/5 (No votes)

See more:

Hello guys
I'm trying to make an array of structure in a way that i dont know the wanted size.
My goal is to take all the information from a text file and put each line in different structure.
i thought about using realloc in a while loop and if i didnt got to the end of file i will realloc one more structure.
I need help in the function "InputData".
Thanks in advance

C++

C#

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

typedef struct
{
    char name[100];
    int** grades[2];

}student;

void Error_Msg(char*);
int InputData(student **,FILE*);
void OutputData(int,student*,FILE*);

int main()
{
    FILE *fp;
    student * arr;
    int size;

    if(!(fp=fopen("Students.txt","r")))
          Error_Msg("The input file is wrong");
    size = InputData(&arr,fp);
    
    fclose(fp);
    if(!(fp=fopen("Students.txt","w")))
        Error_Msg("The output file is wrong");
    OutputData(size,arr,fp);
    fclose(fp);
    return 0;
}


int InputData(student ** p_array, FILE * fp){
 student * temp = *p_array;
 int i=1;

 temp = (student*)malloc(sizeof(student));
 while(fscanf(fp,"%s %d %d %d",temp[i-1].name,&temp[i-1].grades[0],&temp[i-1].grades[1],&temp[i-1].grades[2])!=EOF)
 {
     temp = (student*)realloc(sizeof(student)*1);
     i++;
 }

 return i-1;
}

Posted 12-Aug-13 3:52am

idobry

Add a Solution

Comments

pasztorpisti 12-Aug-13 12:42pm

BTW, realloc() receives two parameters, how do you compile this: temp = (student*)realloc(sizeof(student)*1);. And beware, realloc() has platform dependent behavior when size is zero. Some platforms do not release the memory block in this case (that is really stupid).

2 solutions

Add a Solution

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Fredrik Bornander · Accepted Answer · 2013-08-12T04:49:00

Something like this might do the trick for you;

C

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

typedef struct {
    char name[100];
    int gradeA;
    int gradeB;
    int gradeC;

} student;

student* read_student(FILE* file) {
    student* s = (student*)malloc(sizeof(student));

    if (fscanf(file,"%s %d %d %d", &s->name, &s->gradeA, &s->gradeB, &s->gradeC) != EOF) {
        return s;
    }
    else {
        free(s);
        return NULL;
    }
}

void print_student(student* s) {
    printf("%s %d %d %d\r\n", s->name, s->gradeA, s->gradeB, s->gradeC);
}

int main() {
    FILE* file = fopen("C:\\Temp\\grades.txt", "r");

    student* s = NULL;
    student** students;
    int count = 0;
    while((s = read_student(file))) {
        student** new_students = (student**)malloc(sizeof(student) * (count + 1));
        for(int i = 0; i < count; ++i) {
            new_students[i] = students[i];
        }

        new_students[count] = s;
        free(students);
        students = new_students;
        ++count;
    }

    fclose(file);

    for(int i = 0; i < count; ++i) {
        print_student(students[i]);
    }

    return 0;
}

Instead of realloc I've just dumped the old list and created a new every time.
I would recommend using a some form of linked list structure to track each student read instead.

Hope this helps,
Fredrik

Sergey Alexandrovich Kryukov · Accepted Answer · 2013-08-12T04:40:00

Solution 1

Realloc is expensive operation, so calling it on each line would be more expensive then simply read the file twice: one time for counting the number of lines, the second time for reading those lines.

[EDIT #1]

Even better solution would be the one involving the change in file format. It's always a good idea to write some metadata part at the very beginning of all files. Among other things (what is that files for, what applications are used to write and/or read it), is should inform on the number of records.

On alternative approach would be using non-text (binary) mode of read/write, when records can have the same size.

[EDIT #2]

I failed to mention that the solution based on metadata is only better when the file is written programmatically. Please see the comment by pasztorpisti below.

—SA

Posted 12-Aug-13 4:40am

Sergey Alexandrovich Kryukov

Updated 12-Aug-13 10:57am

v3

Comments

idobry 12-Aug-13 10:52am

Ok, good point i'll give it a try

Sergey Alexandrovich Kryukov 12-Aug-13 11:21am

Will you accept this answer formally (green button)?
—SA

pasztorpisti 12-Aug-13 12:39pm

5ed. Sometimes things like this (pre-setting capacity for containers) may seem stupid (especially if it requires seemingly a lot of work) but can help not only in avoiding lot of reallocs and copying of exisiting items but it avoiding memory fragmentation. I really don't understand why someone gave a one but he has no clue about memory management for sure.
Another technique is preallocating a very large block that is an upper bound of the number of items that follow and later setting the block size to smaller. This can be more effective with custom allocators and it requires a known upper bound on the number of items.

Sergey Alexandrovich Kryukov 12-Aug-13 12:48pm

Exactly. Thank you very much.
By the way, the file is usually buffered well enough to avoid physical addressing of hard drive sectors and redundant physical reads; even if it happens, it happens much less times than the number of reallocations, so it it would be "almost" equivalent to reading the file once. The file may be not closed by file pointer could be rewind to zero position after first read...
—SA

pasztorpisti 12-Aug-13 12:58pm

You are right, today ram is very cheap. Windows does caching with more hundred megs and more gigs if possible. One of my workmates told me a tale about he watching film at home: after some time the media player starts playing with periodic stalls. According to him windows caches the film file so aggressively that it swaps out some parts the player itself... A restart+seek solves the problem. I didn't ask about the windows versions and the methods he used to find this out but if this is true it proves that windows file caching is quite aggressive. :-)

Sergey Alexandrovich Kryukov 12-Aug-13 13:41pm

Right. I put a better alternative suggestion, after [EDIT].
—SA

pasztorpisti 12-Aug-13 16:54pm

Its rather a different then a better alternative. I often use text files when it contains human edited or easy-to debug info. In case of human edited stuff humans would make mistakes often in the metadata and its easier to handle the text with the first approach. Another really dumb solution: Reading in the file in one big chunk and processing it. In many cases its obvious that the file size is nowhere near the available ram. We are doing this in a commercial application even with 10-30Mbyte files even in the smartphone versions. We have plenty of ram. The code is much simpler this way and possible faster in some scenarios. For this temporarily loaded data you can use a temporary heap for allocations if that matters. BTW, in python I'm also scripting in a very comfortable way by reading in everything in one big chunk. If it matters its easy to optimize things later...

Sergey Alexandrovich Kryukov 12-Aug-13 16:56pm

Well, yes, this solution is only better if the file is written programmatically, which I silently assumed.
This is a good point, thank you.
I just added [EDIT #2] crediting your comment.
—SA

pasztorpisti 12-Aug-13 17:05pm

Thank you! Finally we collected a "dozen" of alternatives. :-)

Maciej Los 12-Aug-13 17:13pm

And the discussion between you and Sergey is more valuable then each single answer ;)
@pasztorpisti, if i could, i'll give you a 5!

Sergey Alexandrovich Kryukov 12-Aug-13 17:20pm

Me too. Thank you, Maciej.
—SA

pasztorpisti 12-Aug-13 23:22pm

Thank you Maciej! :-)

Maciej Los 12-Aug-13 17:13pm

A5!
All togeter with comments it's a complete answer ;)

Sergey Alexandrovich Kryukov 12-Aug-13 17:21pm

Thank you, Maciej.
—SA

Herbisaurus 13-Aug-13 2:26am

*****

Sergey Alexandrovich Kryukov 13-Aug-13 2:32am

Thank you,
—SA

H.Brydon 13-Aug-13 18:12pm

+5 for the answer. I owe you +5 for the effort. :-)

Sergey Alexandrovich Kryukov 13-Aug-13 18:55pm

Thank you, Harvey.
—SA

structure dynamic allocation

2 solutions

Solution 2

Solution 1

Add your solution here

Preview 0

structure dynamic allocation

2 solutions

Solution 2

Solution 1

Add your solution here

Preview 0

Existing Members

...or Join us