This is very simple question whose answer I want in lucid language.....

There is fopen() function to open file in C
and
fclose() function to close the file.....

Now what I wanna know is why is it necessary to write fclose() after fopen()and file manipulation things get completed???

Suppose we dont use fclose() and if we open new file by fopen() than what the hell wrong will be there?

What does actuslly fclose() do then????

According to this, http://www.opengroup.org/onlinepubs/...sh/fclose.html, it closes the stream to the file, so I think that it will release memory. But not sure.

i would say another (possible) reason would be to prevent corruption of data. If you close a parent file/program without having the other files closed out, i THINK damage CAN be done. And if nothing else, i think tokico is right. if the file is open (but not being used) it's just eating up resources.

You can fopen as much files as the limits.h header allows, which is a large number, and never use fclose. When your application quits, all open file streams are closed by the C library or the operating system anyway.

A problem rather occurs if you use the same variable name for each fopen (maybe in some nested loop), thereby overwriting your old file pointer with the new one, so that you loose access to those previously opened streams. Doesn't necessarily hurts your application, but it doesn't make sense and is a silly way of programming.

Using fclose is a means of keeping system resources in balance, not hitting the max number of allowed open streams, and to make sure that all changes are buffered back to the hard disk, though the last option depends on the filesystem as well. You can enforce writing the buffered data to disk with the fflush function.

Arch Linux

It closes the file. If the file is not closed, the file state is not necessarily consistent.

You may wonder why this is important (provided that you close the files sometime, I guess...). Well, if the system shuts down with unclosed files the data in them may or may not be lost and the fileystem may or may not be corrupted.

Deliberately corrupting your files or taking unnecessary risks of corrupting the whole filesystem are not generally considered to be good programming practice...

When you write to a file, you're not actually writing to the disk; rather, you're writing to a buffer (memory set aside for buffering input and output). When the buffer fills up, then the disk write actually happens (although you can control this, most of the time you have nothing to do with it, it's done by the system). This small C program, sizes.c, will show you, among other things, the size in bytes of BUFSIZ on your system (on mine it's 8192, yours may differ); BUFSZ is the size of the system buffers. If your program stops for some reason or other (like, say, it crashes) and you have one or more files hanging open with buffer(s) that haven't been written to the disk, well, bad pizza. So the "right" way is open-write-close. The fclose() function flushes the buffer(s) to the disk, thus making sure that everything you "wrote" actually gets there; you can also, if you're doing a large number of writes over a long period of time, invoke the fflush() function periodically to flush the buffers, but you still want to fclose() when you're done (and, no, you don't need to fflush() every write -- that just causes excessive disk input and output and is not useful).

Maybe this is handy, maybe not, but here tis:
Save this as, say, sizes.c, type make sizes and run it.

Hope this helps some.