For pointer structures, the process of writing the structure to a file works similarly to writing a non-pointer structure, but it’s not without some pratfalls. Further, if you have a structure that contains a pointer, things get hinkey quickly.
\n
\nWhen the code declares an array of structure pointers, the process of writing those structures to a file involves ensuring that you’re writing the data and not the pointer itself. For example:<\/p>\n
The The malloc()<\/em> function sets aside a chunk of memory equal to the sizeof<\/em> the At this point, you can write the structure to a file. Use the fwrite()<\/em> function as shown in this Lesson<\/a>, but pay attention! What are you writing to the file?<\/p>\n Here is the proper fwrite()<\/em> statement, assuming And here is the improper fwrite()<\/em> statement:<\/p>\n The address-of operator ( The other pointer issue occurs when the structure contains a pointer member. I’ll be brief: Don’t even bother. The overhead required to write the pointer member’s data is too great and often too inconsistent to be worth the trouble. In fact, if you must write structures to a file, never include pointer members in the structure.<\/p>\n As an example, suppose the As the code runs, you’d allocate storage for the Suppose I allocate storage for My advice is to avoid using pointers when your desire is to read and write structures to a file. Continue reading struct person {
\n char name[32];
\n int age;
\n float weight;
\n};
\nstruct person *myself;<\/code><\/p>\nstruct person<\/code> variable myself<\/code> is a pointer. Storage must be allocated for the pointer to reference:<\/p>\nmyself = (struct person *)malloc( sizeof(struct person) * 1);
\nif( myself == NULL)
\n{
\n fprintf(stderr,\"Unable to allocate memory\\n\");
\n exit(1);
\n}<\/code><\/p>\nperson<\/code> structure. After success, the structure is filled with data:<\/p>\nstrcpy( myself->name,\"Dan Gookin\");
\nmyself->age = 58;
\nmyself->weight = 679.1;<\/code><\/p>\nfp<\/code> is an open file handle:<\/p>\nfwrite(myself,sizeof(struct person),1,fp);<\/code><\/p>\nfwrite(&myself,sizeof(struct person),1,fp);<\/code><\/p>\n&<\/code>) isn’t required when writing a structure pointer because myself<\/code> is already a pointer. If you apply the ampersand, you write the address of the myself<\/code> structure and not the structure’s data.<\/p>\nperson<\/code> structure were defined like this:<\/p>\nstruct person {
\n char *name;
\n int age;
\n float weight;
\n};
\nstruct person *myself;<\/code><\/p>\nname<\/code> pointer, fill the buffer, and so on. When it comes time to write the structure to a file, the sizeof<\/em> operator returns only the bytes required to save the name<\/code> pointer, not the buffer.<\/p>\nname<\/code> when the input is \"Dan Gookin<\/code>” (11 bytes). The name<\/code> pointer member occupies only 4 bytes on my system. I just can’t think of a logical or consistent way to reference the buffer’s data without destroying the concept of writing specific-size chunks to a file. It’s too much of a bother, which is why I recommend not writing structures to a file when the structure includes pointer members.<\/p>\n","protected":false},"excerpt":{"rendered":"