Hi,

I need to write a struct in a file and then later on need to read this structure from the file. Can any one provide me an example that how can I do this.

following is the example structure that I want to write


struct myIP
{
char header;
int length;
char data;
};

thank you

Just use the regular write() and read() functions. If you're not familiar with those, do this at the command line:

You'll be using the C & operator to make a pointer to the struct in question. If you're not familiar with the & operator, google this:

You should also be aware that the data you write will not be portable from one architecture to another.

Hope this helps.

It is also true that it will most likely not be able to be read by other programs using read. Also it may be eazier and possibly safer to use fread and fwrite rather then the low level file operators.

Also, pointers won't remain valid and any dynamic memory associated won't carry over. The only reliable way is to decompose the structure into its components and write to the file in some parseable format. For example, separate data by spaces or some other symbol using fprintf, then parse with fgets, strtok, and the strto* functions. The real problem comes if you have non-string pointers. Then you are talking about an entire file format and parser.
ta0kira

When writing structs to a file, you need to consider a couple things:

1. Endianness- When numbers are stored in memory, they are stored in either big endian or little endian. PowerPC processors (and others) use big endian, while Intel processors (and others) use little endian. (actually, PowerPC can be either big endian or little endian, but it's big endian by default). Suppose you want to store the number 0x12345678. If you do this:

char c[4];
unsigned long n=0x12345678;
*(unsigned long*)c = n;

In big endian, it will be this:

c[0]=0x12;
c[1]=0x34;
c[2]=0x56;
c[3]=0x78;

In little endian, like this:

c[0]=0x78;
c[1]=0x56;
c[2]=0x34;
c[3]=0x12;

Register shifts won't be affected (i.e. 0x12345678<<8 will still be 0x34567800). When working with numbers mathematically, it's the same on big endian or little endian platforms, but when you break numbers down into smaller units (like bytes) it certainly matters. Therefore, writing structs (or numbers larger than char) to a file on a big endian system will result in different byte ordering than doing so on a little endian system.

2. Even alignment- I don't think this is present in mainstream processors (i.e. PowerPC and Intel), but it is in the Motorola 68k processors. The 68k can't write shorts or longs at odd addresses without writing them one byte at a time, so when you say:

struct myIP
{
char header;
int length;
char data;
};

It might be stored literally as:

struct myIP
{
char header;
char paddingforheader;
int length;
char data;
char paddingforlength;
};

Therefore, group your chars together to save space on 68k platforms.

Overall, if you're worried about cross-architecture compatibility, heed these notes. Otherwise, at least know this issue exists so that when you do need to write a cross-architecture program, you'll know how.

Quoth the highly esteemed exvor:
Fear not. As long as the structure doesn't include pointers and is being run always on the same architecture with (basically) the same compiler, you're fine.
Be not uncertain. Doubt not. There is nothing to be gained with respect to writing and reading structures through fread() and fwrite() instead of read() and write().

The most likely complication is that you can't always know that a later program (perhaps the same one) might be compiled with a different compiler. As JoeyAdams says, this might mess up alignment of items in a struct, giving you problems.

All you gain from this is saving disk space (how much would you really be saving, anyway?) and speed. Unless writing and reading these records consumes a large percentage of your processing time, go with ta0kira's idea of writing the data in human-readable form. It will be easier to maintain the code if your eyes can see the data.

fwrite and fread are, also, generally faster, since they buffer buffer the input/output. You can do the same with read and write, but you usually end up reimplementing fread/fwrite, only not as robust or safe.

Edit: It is also ANSI C.

-
OP:
For now, stick to the basics. Try using both ta0kira's method, and just straight binary reading/writing as well. You're learning, so it is all good for you and you'll learn a lot both ways. When you start getting a little more advanced then you can start dealing with more advanced serialization.

Thanks all of you guys you have really helped me.

regards,
Imran

also, you may have endian problems if you transfer between processors,
e.g. sparc and intel and power PC and VAX

so if you intend to do it properly you need to address this issue

it's generally easier to save ascii if you can, and humans can read it too.