char pointer file I/O - c++

Question

I am struggling to understand the behaviour of the program. The test.txt file is of 16 bytes where as the size of text pointed by pointer p of structure is more than 16 bytes(the string text) there are other int values too. How the extra data is stored in test file with only 16 bytes. The file is read by another structure 'b' but it gives correct values like 'a'.
int main()
{
string text("C:\\Users\\Chitra\\Desktop\\Capture.JPG");
string filepath("C:\\Users\\Chitra\\Desktop\\New folder\\Project1\\Project1\\test.txt");
fstream fout(filepath,ios::out|ios::binary);
fstream fin(filepath,ios::in|ios::binary);
struct block
{
int value;
int size;
const char* p;
int some;
};
block a;
a.value = 1457745;
a.size = text.length();
a.p = text.c_str();
a.some = 97877;
fout.write((char*)&a, sizeof(a));
fout.close();
block b;
fin.read((char*)&b, sizeof(b));
fin.seekg(0, ios::end);
cout << "file size " << fin.tellg();
fin.close();
cout << "\nsize a " << sizeof(a) << " size b " << sizeof(b);
cout << "\n"<<b.value << " " << b.size << " " << b.p << " " << b.some;
getchar();
return 0;
}

Answer 1

The file is only 16 bytes because when you write a.p to the file, you are writing a four-byte pointer value which points to the string in memory -- you are not writing out the string data itself.
The reason that it appears to work is that you immediately read the same pointer value back into another pointer variable in the same process, so when you read the memory pointed to by b.p, it is the same as the memory pointed to by a.p, that is, the NUL-terminated string text.
If you created a second program which just did the file read, without declaring the string text, you should expect to encounter an error or at least, not see the text.
int main()
{
string filepath("C:\\Users\\Chitra\\Desktop\\New folder\\Project1\\Project1\\test.txt");
fstream fin(filepath,ios::in|ios::binary);
struct block
{
int value;
int size;
const char* p;
int some;
};
block b;
fin.read((char*)&b, sizeof(b));
fin.seekg(0, ios::end);
cout << "file size " << fin.tellg();
fin.close();
cout << "\n size b " << sizeof(b);
cout << "\n"<<b.value << " " << b.size << " " << b.p << " " << b.some;
getchar();
return 0;
}

Answer 2

as Sam Mikes said block.p is pointer and you only save its value (the value of a pointer is an address of the memory it point) and because of a.p is still point to it in memory the memory do not change add delete a; like code bellow and see the different
*noted that : sizeof a and b and block is the same you can use sizeof(a) or sizeof(b) or sizeof(block) instead
#include <string>
#include<iostream>
#include <fstream>
using namespace std;
int main(){
string text("C:\\Users\\Chitra\\Desktop\\Capture.JPG");
string filepath("C:\\Users\\Chitra\\Desktop\\New folder\\Project1\\Project1\\test.txt");
fstream fout(filepath,ios::out|ios::binary);
fstream fin(filepath,ios::in|ios::binary);
struct block {
int value;
int size;
const char* p;
int some;
};
block a;
a.value =1457745;
a.size=text.length();
a.p=text.c_str();
a. some=97877;
fout.write((char*)&a,sizeof(a));
fout.close();
delete a.p;
block b;
fin.read((char*)&b,sizeof(b));
fin.seekg(0,ios::end);
cout<<"file size "<<fin.tellg();
fin.close();
cout<<"\nsize a "<<sizeof(a)<<" size b "<<sizeof(b)<<" size block "<<sizeof (block);
cout<<"\n"<<b.value<<" "<<b.size<<" "<<b.p<<" "<<b.some;
getchar();
return 0;
}

Answer 3

You can't just do...
fout.write(pointer, bytes);
...for any values of pointer and byte, because the data doesn't exist in contiguous memory. You must write the data embedded in the block without the pointer, and the pointed-to string data, separately. That's easiest if you move the pointer to the end of the structure, then write:
struct block
{
int value;
int some;
int size;
const char* p;
};
fout.write((char*)&a, sizeof a - sizeof a.p);
// could also "offsetof(block, p)" for size - possibly more fragile
fout.write(a.p, a.size);
Then, to read the data back:
block b;
fin.read((char*)&b, sizeof b - sizeof b.p);
b.p = new char[b.size + 1];
fin.read(b.p, b.size);
b.p[b.size + 1] = '\0'; // guarantee NUL termination
Sometime later you'll need to delete[] b.p; to deallocate the memory returned by the new[]. Alternatively, you could use another string:
block b;
fin.read((char*)&b, sizeof b - sizeof b.p);
std::string b_string(b.size, ' '); // initially b.size spaces
fin.read(&b_string[0], b.size); // overwrite with data from the file...
With the std::string, deallocation happens automatically when the destructor is invoked.
(It's actually best to use a C++ serialisation library with std::fstreams, like boost's here.)