read structure from binary file having pointer pointed to memory - c++

Question

struct st {
char *p;
int len;
};
this is the structure which i need to write to a binary file, along with the string which is saved in
char *p
I am supposed to write a binary file with the char array data. After writing to binary file. Is should also be able to read it in the same structure from binary file.
I tried using FSEEK_END to get the binary size, and doing fread according to file size, but it is not saving string. Please suggest. Any help/suggestion/pointer would be appreciated.
thanks in advance.
sample code:
struct st {
char *p;
int len;
};
struct st varr;
varr.len = 100;
varr.p = new char[gen];
strcpy(varr.p, "Hello World");
FILE *p;
p=fopen("address","wb");
fwrite(&varr,sizeof(struct st),1,p);
fclose(p);
this will write me the pointer to the binary file. But i want to write here whole string, but the point is, it should done with one fwrite.

Answer 1

There is no use writing this to a binary file. A text file would suffice.
However, if this is your homework assignment (or so), I suggest you proceed as follows:
write the length as an integer;
write len bytes of the string. This does not include a terminating null.
When reading back:
read the integer length;
allocate memory of this length plus one byte
read the string into that memory and add the terminating null.
Fill your structure with this length and the pointer to allocated memory.
In your comments you keep iterating you want to read and write in one step. With your current data structure that is not possible because the character string wil always be somewhere else in memory and fwrite can only write a contiguous block of memory.
However, would you change your data structure to:
struct st{
char p[128];
int len;
};
then you can write and read in one go because now the struct is a contiguous memory block. But now the string is limited to this 128 bytes(or any size you make it).

Answer 2

I would suggest saving the strlen(p) first, followed by all the chars pointed by char *p. If you try to fwrite the struct as it is, you'll end up (in the file) with the value for the address with regrads to the first char. You do not want to save the address of the 1st char, do you?

Answer 3

If you are so much concerned about not having two fwrite you can have wrapper structure with zero length array.
struct st_wrap {
int len;
char p[0];
};
struct st_wrap *temp= malloc (sizeof (struct st_wrap ) + strlen(varr.p)+1);
temp->len = strlen(varr.p);
//Copy the data
strcpy(temp->p,varr.p);
//Then write it to file
fwrite(temp,sizeof(struct st_wrap)+strlen(varr.p),1,p);

Answer 4

Assuming you have written the length and string to binary file:
FILE* fp = fopen("file.bin", "wb");
/* writing */
st str = { .p = "foo", .len = 3 };
fwrite((char*)(&str.len), sizeof(str.len), sizeof(str.len), fp);
fwrite(str.p, str.len, str.len, fp);
You can now (in a different context) read the content from file into the struct object:
FILE* fp = fopen("file.bin", "rb");
st str;
/* read length */
fread((char*)&str.len, sizeof(str.len), sizeof(str.len), fp);
/* allocate enough space */
str.p = malloc((str.len + 1) * sizeof(char));
/* read string */
fread(str.p, str.len + 1, str.len + 1, fp);
Remember to free memory when you're done with p:
free(str.p);

Answer 5

I tried lot of ways, but #kiran Biradar's answer helped me a lot. hence displaying the working code here.
WriteBinaryFile.cpp
struct st_wrap {
int len;
int crc;
char p[0];
};
int main ()
{
char p[100] = "Hello World";
struct st_wrap *temp= (struct st_wrap*) malloc (sizeof (struct st_wrap ) + strlen(p)+1);
temp->len = strlen(p);
temp->crc = 400;
strcpy(temp->p,p);
cout << temp->p << endl;
cout << temp->len << endl;
cout << temp->crc << endl;
FILE *p1;
p1=fopen("binary.dat","wb");
fwrite(temp,sizeof(struct st_wrap)+strlen(p),1,p1);
fclose(p1);
}
ReadBinaryFile.cpp
struct st_wrap {
int len;
int crc;
char p[0];
};
int main ()
{
struct st_wrap *vw;
FILE *f=fopen("binary.dat","rb");
fseek(f, 0, SEEK_END);
long int filesize = ftell(f);
fseek(f, 0, SEEK_SET);
vw = (struct st_wrap*) malloc (filesize);
fread(vw,filesize,1,f);
cout << vw->len << endl;
cout << vw->p << endl;
cout << vw->crc << endl;
return 0;
}