I need to know which is a better option, provided they both work as intended. I need to open a file, and load everything up to the first null character into a malloc()ed block. There is going to be other data after the first null terminator. The file would look like <text I need to read> <random binary>. Which option would be better?
First of here’s a struct, because actually I need to record both the data and the size.
struct DataBlock {
char *Buffer;
unsigned long Size;
};
So this?
struct DataBlock MakePreNulltermData(FILE *File) {
unsigned int Len = 0;
while (fgetc(File)) {
Len++;
}
char *const Buffer = malloc(Len+1);
if (!Buffer) {
abort();
}
fread(Buffer, 1, Len, EntryFile);
return (struct DataBlock){Buffer, Len};
}
Or this?
struct DataBlock MakePreNulltermData(FILE* File) {
fseek(File, 0, SEEK_END);
unsigned long Size = ftell(File);
rewind(File);
char *Buffer = malloc(Size+1);
if (!Buffer) {
abort();
}
fread(Buffer, 1, Size, File);
const unsigned long Len = memchr(Buffer, 0, Size)-Buffer;
if (!Buffer = realloc(Buffer, Len)) {
abort();
}
return (struct DataBlock){Buffer, Len};
}
The first one reads the data twice from the file. I don’t know how slow that is, but the second one reads any given byte from the file once. But the second needs a bigger malloc() block up front, and then realloc()ed to match the data. The size of the pre-nullterm data is completely arbitrary and estimating the size for the purpose of this question is, well, out of the question. Which should I use given the circumstances, can I make either of them more efficient?
Should I count the number of bytes until the first null char, and allocate once or should I read the entire file into a data block, then count the bytes until the first null char IN RAM in the malloc() block, then resize the malloc block? Read twice and allocate once, or read once and allocate twice?
