Writing with FILE pointer, reading with ifstream - c++

Question

I have to handle with code where at one side information is written to a file using FILE* and on the other side it is read-in using ifstream.
I tried to compile a dummy code which shows the same behavior as the original code:
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
int main()
{
FILE* outFile = fopen("testFile", "w");
char* posBuf = NULL;
unsigned int counter = 0;
posBuf = (char*) malloc( sizeof(int) + 2*sizeof(double) );
int iDummy = 123;
memcpy(posBuf+counter, (const void*) &iDummy, sizeof(int));
counter += sizeof(int);
double dDummy = 456.78;
memcpy(posBuf+counter, (const void*) &dDummy, sizeof(double));
counter += sizeof(double);
dDummy = 111.222;
memcpy(posBuf+counter, (const void*) &dDummy, sizeof(double));
fputs(posBuf, outFile);
fclose(outFile);
/////////////////////
std::ifstream myfile;
myfile.open("testFile", std::ios::in|std::ios::binary);
myfile.seekg (0, std::ios::end);
unsigned int length = myfile.tellg();
myfile.seekg (0, std::ios::beg);
char* posBuf2 = (char*) malloc( length );
myfile.read(posBuf2, length);
counter = 0;
int idummy = 0;
memcpy((void*) &idummy, posBuf2+counter, sizeof(int));
counter += sizeof(int);
printf("read integer: %u\n", idummy);
double ddummy = 1.0;
memcpy((void*) &ddummy, posBuf2+counter, sizeof(double));
counter += sizeof(double);
printf("read double: %f\n", ddummy);
ddummy = 1.0;
memcpy((void*) &ddummy, posBuf2+counter, sizeof(double));
counter += sizeof(double);
printf("read double: %f\n", ddummy);
myfile.close();
/////////////////////
FILE* inFile = fopen("testFile", "r");
char* posBuf3 = NULL;
unsigned int c = 0;
while ( ! feof (inFile) )
{
posBuf3 = (char*) realloc((void*) posBuf3, c+4);
fgets(posBuf3+c, 4, inFile);
c += 4;
}
idummy = 0;
memcpy((void*) &idummy, posBuf, sizeof(int));
printf("read again integer: %u\n", idummy);
ddummy =1.0;
memcpy((void*) &ddummy, posBuf+sizeof(int), sizeof(double));
printf("read again double: %f\n", ddummy);
ddummy =1.0;
memcpy((void*) &ddummy, posBuf+sizeof(int)+sizeof(double), sizeof(double));
printf("read again double: %f\n", ddummy);
return 0;
}
The output I get from that is:
read integer: 123
read double: 0.000000
read double: 0.000000
read again integer: 123
read again double: 456.780000
read again double: 111.222000
As you can see, the deserialization only works if I use FILE* also for the reading of the file.
QUESTION: Any explanation for that behavior?
Thanks!
UPDATED:
1) open ifstream using std::ios::in|std::ios::binary
2) fix malloc

Answer 1

A few problems with the posted code:
it is writing beyond the bounds of the memory allocated for posBuf (1 int and 2 doubles are copied to the memory, but only sizeof(int) + sizeof(double) is allocated), which is undefined behaviour.
fputs() treats its argument as a null terminated string and so will stop writing when it encounters a null character. Open the file in binary mode and use fwrite() instead which does not treat its input as a null terminated string.
There are several other issues with the code;
it is a horrible mix of C and C++
avoidable explicit dynamic memory management (never mind malloc() and realloc()). Simply replaced with:
char posBuf[sizeof(int) + 2 * sizeof(double)];
while (!feof(inFile)).
there is practically no checking of the success of I/O operations