C langugae : File Input/Output

Data Organization
All data stored on the disk is in binary form. This binary data is stored on the disk varies from one OS to another. However, this does not affect the C programmer since he has to use only the library functions written for the particular OS to be able to perform input/output. It is the compiler vendor’s responsibility to correctly implement these library functions by taking the help of OS. This is illustrated in Figure
After storing data on the disk, the computer helps you enter, find, change, and delete the data. The computer and C are simply tools to help you manage and process data.
Why Use a Disk?
The typical computer system has much less memory storage than hard disk storage. Your disk drive holds much more data than can fit in your computer's RAM. The disk memory, because it is nonvolatile, lasts longer because the disk retains its contents when you power-off your computer. Also, when your data changes, you (or more important, your users) do not have to edit the program and look for a set of assignment statements. Instead, the users run previously written programs that make changes to the disk data.
Types of Disk File Access
The programs can access files in two ways: through sequential access or random access. Your application determines the method you should choose. The access mode of a file determines how you read, write, change, and delete data from the file. Some of your files can be accessed in both ways, sequentially and randomly.Your C compiler might offer additional ways to access disk files with a library of specific I/O functions.A sequential file must be accessed in the same order the file was written. This is analogous to cassette tapes: You play music in the same order it was recorded(You can quickly fast-forward or rewind through songs but It is difficult, and sometimes impossible, to insert song in the middle of a Cassette.Random access files in any order you want. Think of data in a random access file as you would think of songs on a compact disc or a record; you can go directly to any song you want without having to play or fast-forward through the other songs. If you want to play the first song, the sixth song, and then the fourth song, you can do so.
Communicating with Files
File : - A file represents a sequence of bytes. The fopen( ) function associates a file with a stream and initializes an object of the type FILE, which contains all the information necessary to control the stream. Such information includes a pointer to the buffer used; a file position indicator , which specifies a position to access in the file; and flags to indicate error and end-of-file conditions.
Each of the functions that open filesnamely fopen( ), freopen( ), and tmpfile( )returns a pointer to a FILE object for the stream associated with the file being opened. Once you have opened a file, you can call functions to transfer data and to manipulate the stream. Such functions have a pointer to a FILE objectcommonly called a FILE pointeras one of their arguments. The FILE pointer specifies the stream on which the operation is carried out.
The I/O library also contains functions that operate on the file system, and take the name of a file as one of their parameters. These functions do not require the file to be opened first. They include the following:
* The remove( ) function deletes a file (or an empty directory). The string argument is the file's name. If the file has more than one name, then remove( ) only deletes the specified name, not the file itself. The data may remain accessible in some other way, but not under the deleted filename.
* The rename( ) function changes the name of a file (or directory). The function's two string arguments are the old and new names, in that order. The remove( ) and rename( ) functions both have the return type int, and return zero on success, or a non-zero value on failure.
Text Streams and the Binary Streams
Text Streams: - A text stream transports the characters of a text that is divided into lines. A line of text consists of a sequence of characters ending in a newline character. A line of text can also be empty, meaning that it consists of a newline character only. The last line transported may or may not have to end with a newline character, depending on the implementation.
The internal representation of text in a C program is the same regardless of the system on which the program is running. Thus text input and output on a given system may involve removing, adding, or altering certain characters. For example, on systems that are not Unix-based, end-of-line indicators ordinarily have to be converted into newline characters when reading text files , as on Windows systems for instance, where the end-of-line indicator is a sequence of two control characters, \r (carriage return) and \n (newline). Similarly, the control character ^Z (character code 26) in a text stream on Windows indicates the end of the stream.
Binary Streams: - A binary stream is a sequence of bytes that are transmitted without modification. In other words, the I/O functions do not involve any interpretation of control characters when operating on binary streams . Data written to a file through a binary stream can always be read back unchanged on the same system. However, in certain implementations there may be additional zero-valued bytes appended at the end of the stream.
Binary streams are normally used to write binary datafor example, database recordswithout converting it to text. If a program reads the contents of a text file through a binary stream, then the text appears in the program in its stored form, with all the control characters used on the given system.

Although ANSI C provides for both a binary view and a text view, these views can be implemented identically. For example, because Unix uses just one file structure, both views are the same for Unix implementations.
Buffers
A stream has a buffer in which it collects characters, which are transferred as a block to or from the file. Sometimes you don't want buffering, however. For example, after an error has occurred, you might want to write data to a file as directly as possible.
Streams are buffered in one of three ways:
Fully buffered : - The characters in the buffer are normally transferred only when the buffer is full.
Line-buffered : - The characters in the buffer are normally transferred only when a newline character is written to the buffer, or when the buffer is full. A stream's buffer is also written to the file when the program requests input through an unbuffered stream, or when an input request on a line-buffered stream causes characters to be read from the host environment.
Unbuffered : - Characters are transferred as promptly as possible.
Standard I/O
The standard I/O package has two advantages, besides portability, over low-level I/O. First, it has many specialized functions that simplify handling different I/O problems. For example, printf() converts various forms of data to string output suitable for terminals. Second, input and output are buffered. That is, information is transferred in large chunks (typically 512 bytes at a time or more) instead of a byte at a time. When a program reads a file, for example, a chunk of data is copied to a buffer—an intermediate storage area. This buffering greatly increases the data transfer rate. The program can then examine individual bytes in the buffer. The buffering is handled behind the scenes, so you have the illusion of character-by-character access. (You can also buffer low-level I/O, but you have to do much of the work yourself.). If you're a Windows user, you might have to run the program in an MS-DOS window after compiling. If you're a Macintosh user, you should use console.h and the ccommand() function , "Character Strings and String Functions," and in the Code Warrior documentation. Alternatively, you can alter the program to use puts() and gets() instead of command-line arguments to get the filename.)
File Operations
There are different operations that can be carried out on a file. These are:
* Creation of a new file
* Opening an existing file Reading from a file
* Writing to a file
* Moving to a specific location in a file (seeking)
* Closing a file
Access Modes
The access mode specified by the second argument to fopen( ) or freopen( ) determines what input and output operations the new stream permits. The permissible values of the mode string are restricted. The first character in the mode string is always r for "read," w for "write," or a for "append," and in the simplest case, the string contains just that one character. However, the mode string may also contain one or both of the characters + and b (in either order: +b has the same effect as b+).
A plus sign (+) in the mode string means that both read and write operations are permitted. However, a program must not alternate immediately between reading and writing. After a write operation, you must call the fflush( ) function or a positioning function (fseek( ), fsetpos( ), or rewind( )) before performing a read operation. After a read operation, you must call a positioning function before performing a write operation.
A b in the mode string causes the file to be opened in binary modethat is, the new stream associated with the file is a binary stream. If there is no b in the mode string, the new stream is a text stream.
If the mode string begins with r, the file must already exist in the file system. If the mode string begins with w, then the file will be created if it does not already exist. If it does exist, its previous contents will be lost, because the fopen( ) function truncates it to zero length in "write" mode.
A mode string beginning with a (for append) also causes the file to be created if it does not already exist. If the file does exist, however, its contents are preserved, because all write operations are automatically performed at the end of the file.

Mode Strings for fopen()

FILE *prnt; /* Points to the printer */
main()
{
prnt = fopen("LPT1", "w");
fprintf(prnt, "Printer line 1\n"); // 1st line printed
fprintf(prnt, "Printer line 2\n"); // 2nd line printed
fprintf(prnt, "Printer line 3\n"); // 3rd line printed
fclose(prnt);
return 0;
}
Reading from a File
3. This program asks the user for a filename and prints the contents of the file to the screen. If the file does not exist, the program displays an error message:
/* Filename: anuj3.C
Reads and displays a file */
#include < stdio.h >
FILE *fp;
main()
{
char filename[12]; // Holds user's filename
int inChar; // Input character
printf(''What is the name of the file you want to see? ");
gets(filename);
if ((fp=fopen(filename, "r"))==NULL)
{ printf("\n\n*** That file does not exist ***\n");
exit(); // Exits program
}
inChar = getc(fp); // Reads first character
while (inChar != EOF)
{ putchar(inChar);
inChar = getc(fp);
}
fclose(fp);
return 0;
}
4. The following program reads one file and copies it to another. You might want to use such a program to back up important data in case the original file gets damaged.: -
/* Filename: anuj4.C Makes a copy of a file */
#include < stdio.h >
FILE *inFp;
FILE *outFp;
main()
{
char inFilename[12]; /* Holds original filename */
char outFilename[12]; /* Holds backup filename */
int inChar; /* Input character */
printf(''What is the name of the file you want
to back up? ");
gets(inFilename);
printf("What is the name of the file ");
printf("you want to copy %s to? ", inFilename);
gets(outFilename);
if ((inFp=fopen(inFilename, "r"))==NULL)
{ printf("\n\n*** %s does not exist ***\n", inFilename);
exit(); /* Exits program */
} if ((outFp=fopen(outFilename, "w"))==NULL)
{ printf("\n\n*** Error opening %s ***\n'', outFilename);
exit(); /* Exits program */
} printf("\nCopying . . . \n"); /* Waiting message */
while ((inChar = getc(inFp)) != EOF) /* Gets input character */
{ putc(inChar, outFp); } /* Writes the character to the backup file */
printf("\nThe files are copied.\n");
fclose(inFp);
fclose(outFp);
return 0;
}