Home | | Data Structures | | Programming and Data Structures I | File handling concepts - read, write and Manipulations

Chapter: Programming and Data Structures - C Programming Advanced Features

| Study Material, Lecturing Notes, Assignment, Reference, Wiki description explanation, brief detail |

File handling concepts - read, write and Manipulations

Abstractly, a file is a collection of bytes stored on a secondary storage device, which is generally a disk of some kind. The collection of bytes may be interpreted, for example, as characters, words, lines, paragraphs and pages from a textual document; fields and records belonging to a database; or pixels from a graphical image.

FILE HANDLING CONCEPTS

 

In this section, we will discuss about files which are very important for storing information permanently. We store information in files for many purposes, like data processing by our programs.

 

What is a File?

Abstractly, a file is a collection of bytes stored on a secondary storage device, which is generally a disk of some kind. The collection of bytes may be interpreted, for example, as characters, words, lines, paragraphs and pages from a textual document; fields and records belonging to a database; or pixels from a graphical image. The meaning attached to a particular file is determined entirely by the data structures and operations used by a program to process the file. It is conceivable (and it sometimes happens) that a graphics file will be read and displayed by a program designed to process textual data. The result is that no meaningful output occurs (probably) and this is to be expected. A file is simply a machine decipherable storage media where programs and data are stored for machine usage.

 

Essentially there are two kinds of files that programmers deal with text files and binary files. These two classes of files will be discussed in the following sections.

 

ASCII Text files

A text file can be a stream of characters that a computer can process sequentially. It is not only processed sequentially but only in forward direction. For this reason a text file is usually opened for only one kind of operation (reading, writing, or appending) at any given time.

 

Similarly, since text files only process characters, they can only read or write data one character at a time. (In C Programming Language, Functions are provided that deal with lines of text, but these still essentially process data one character at a time.) A text stream in C is a special kind of file.

 

Depending on the requirements of the operating system, newline characters may be converted to or from carriage-return/linefeed combinations depending on whether data is being written to, or read from, the file. Other character conversions may also occur to satisfy the storage requirements of the operating system. These translations occur transparently and they occur because the programmer has signalled the intention to process a text file.

 

Binary files

 

A binary file is no different to a text file. It is a collection of bytes. In C Programming Language a byte and a character are equivalent. Hence a binary file is also referred to as a character stream, but there are two essential differences.

 

1.     No special processing of the data occurs and each byte of data is transferred to or from the disk unprocessed.

 

C Programming Language places no constructs on the file, and it may be read from, or written to, in any manner chosen by the programmer.

Binary files can be either processed sequentially or, depending on the needs of the application, they can be processed using random access techniques. In C Programming Language, processing a file using random access techniques involves moving the current file position to an appropriate place in the file before reading or writing data. This indicates a second characteristic of binary files.

 

They a generally processed using read and write operations simultaneously.

 

For example, a database file will be created and processed as a binary file. A record update operation will involve locating the appropriate record, reading the record into memory, modifying it in some way, and finally writing the record back to disk at its appropriate location in the file. These kinds of operations are common to many binary files, but are rarely found in applications that process text files.

Creating a file and output some data

In order to create files we have to learn about File I/O i.e. how to write data into a file and how to read data from a file. We will start this section with an example of writing data to a file. We begin as before with the include statement for stdio.h, then define some variables for use in the example including a rather strange looking new type.

/* Program to create a file and write some data the file */ #include <stdio.h>

 

#include <stdio.h> main( )

{

 

FILE *fp; char stuff[25]; int index;

 

fp = fopen("TENLINES.TXT","w"); /* open for writing */ strcpy(stuff,"This is an example line.");

for (index = 1; index <= 10; index++)

 

fprintf(fp,"%s Line number %d\n", stuff, index); fclose(fp); /* close the file before ending program */

 

}

 

The type FILE is used for a file variable and is defined in the stdio.h file. It is used to define a file pointer for use in file operations. Before we can write to a file, we must open it. What this really means is that we must tell the system that we want to write to a file and what the file name is. We do this with the fopen() function illustrated in the first line of the program. The file pointer, fp in our case, points to the file and two arguments are required in the parentheses, the file name first, followed by the file type.

 

The file name is any valid DOS file name, and can be expressed in upper or lower case letters, or even mixed if you so desire. It is enclosed in double quotes. For this example we have chosen the name TENLINES.TXT. This file should not exist on your disk at this time. If you have a file with this name, you should change its name or move it because when we execute this program, its contents       will  be  erased.  If  you  don’t  have create one and put some data into it. You are permitted to include a directory with the file name.The directory must, of course, be a valid directory otherwise an error will occur. Also,

 

because of the way C handles literal\’ strings,mustbe written twice. For example, if the file is to be stored in the \PROJECTS sub directory then the file

 

name should \\PROJECTS\\beenteredTENLINESas .“TXT”. The second pa attribute and can be any of three letters, r, w, or a, and must be lower case.

Reading (r)

When an r is used, the file is opened for reading, a w is used to indicate a file to be used for writing, and an a indicates that you desire to append additional data to the data already in an existing file. Most C compilers have other file attributes available; check your Reference Manual for details. Using the r indicates that the file is assumed to be a text file. Opening a file for reading requires that the file already exist. If it does not exist, the file pointer will be set to NULL and can be checked by the program.

 

Here is a small program that reads a file and display its contents on screen.

 

/* Program to display the contents of a file on screen */ #include <stdio.h>

void main()

 

{

 

FILE *fopen(), *fp; int c;

 

fp = fopen("prog.c","r"); c = getc(fp) ;

while (c!= EOF)

 

{

 

putchar(c); c = getc(fp);

}

 

fclose(fp);

}

 

Writing (w)

When a file is opened for writing, it will be created if it does not already exist and it will be reset if it does, resulting in the deletion of any data already there. Using the w indicates that the file is assumed to be a text file.

 

Here is the program to create a file and write some data into the file.

 

#include <stdio.h> int main()

 

{

FILE *fp;

 

file = fopen("file.txt","w");

/*Create a file and add text*/

 

fprintf(fp,"%s","This is just an example :)"); /*writes data to the file*/ fclose(fp); /*done!*/

return 0;

 

}

Appending (a)

When a file is opened for appending, it will be created if it does not already exist and it will be initially empty. If it does exist, the data input point will be positioned at the end of the present data so that any new data will be added to any data that already exists in the file. Using the a indicates that the file is assumed to be a text file.

 

Here is a program that will add text to a file which already exists and there is some text in the file.

 

#include <stdio.h> int main()

{

 

FILE *fp

file = fopen("file.txt","a");

 

fprintf(fp,"%s","This is just an example :)"); /*append some text*/ fclose(fp);

 

return 0;

}

Outputting to the file

The job of actually outputting to the file is nearly identical to the outputting we have already done to the standard output device. The only real differences are the new function names and the addition of the file pointer as one of the function arguments. In the example program, fprintf replaces our familiar printf function name, and the file pointer defined earlier is the first argument within the parentheses. The remainder of the statement looks like, and in fact is identical to, the printf statement.

Closing a file

To close a file you simply use the function fclose with the file pointer in the parentheses. Actually, in this simple program, it is not necessary to close the file because the system will close all open files before returning to DOS, but it is good programming practice for you to close all files in spite of the fact that they will be closed automatically, because that would act as a reminder to you of what files are open at the end of each program.

 

You can open a file for writing, close it, and reopen it for reading, then close it, and open it again for appending, etc. Each time you open it, you could use the same file pointer, or you could use a different one. The file pointer is simply a tool that you use to point to a file and you decide what file it will point to. Compile and run this program. When you run it, you will not get any output to the monitor because it doesn’t generate any named TENLINES.TXT and type it; that is where your output will be. Compare the output with that specified in the program; they should agree! Do not erase the file named TENLINES.TXT yet; we will use it in

some of the other examples in this section.

 

Opening Files

 

You can use the fopen( ) function to create a new file or to open an existing file, this call will initialize an object of the type FILE, which contains all the information necessary to control the stream. Following is the prototype of this function call:

 

FILE *fopen( const char * filename, const char * mode );

 

Here, filename is string literal, which you will use to name your file and access mode can have one of the following values:

 

Mode Description r Opens an existing text file for reading purpose.


w       Opens a text file for writing, if it does not exist then a new file is created. Here your program will start writing content from the beginning of the file.

a        Opens a text file for writing in appending mode, if it does not exist then a new file is created. Here your program will start appending content in the existing file content.

 

r+ Opens a text file for reading and writing both.

 

w+ Opens a text file for reading and writing both. It first truncate the file to zero length if it exists otherwise create the file if it does not exist.

 

a+ Opens a text file for reading and writing both. It creates the file if it does not exist. The reading will start from the beginning but writing can only be appended.

 

 

 

If you are going to handle binary files then you will use below mentioned access modes instead of the above mentioned:

 

"rb", "wb", "ab", "ab+", "a+b", "wb+", "w+b", "ab+", "a+b"

 

Closing a File

 

To close a file, use the fclose( ) function. The prototype of this function is:

 

int fclose( FILE *fp );

 

The fclose( ) function returns zero on success, or EOF if there is an error in closing the file. This function actually, flushes any data still pending in the buffer to the file, closes the file, and releases any memory used for the file. The EOF is a constant defined in the header file stdio.h.

 

There are various functions provide by C standard library to read and write a file character by character or in the form of a fixed length string. Let us see few of the in the next section.

Writing a File

 

Following is the simplest function to write individual characters to a stream:

 

int fputc( int c, FILE *fp );

 

The function fputc() writes the character value of the argument c to the output stream referenced by fp. It returns the written character written on success otherwise EOF if there is an error. You can use the following functions to write a null-terminated string to a stream:

 

int fputs( const char *s, FILE *fp );

 

The function fputs() writes the string s to the output stream referenced by fp. It returns a non-negative value on success, otherwise EOF is returned in case of any error. You can use int fprintf(FILE *fp,const char *format, ...) function as well to write a string into a file. Try the following example:

 

#include <stdio.h> main()

{

 

FILE *fp;

 

fp = fopen("/tmp/test.txt", "w+"); fprintf(fp, "This is testing for fprintf...\n"); fputs("This is testing for fputs...\n", fp); fclose(fp);

 

}

 

When the above code is compiled and executed, it creates a new file test.txt in /tmp directory and writes two lines using two different functions. Let us read this file in next section.

 

Reading a File

 

Following is the simplest function to read a single character from a file:

 

int fgetc( FILE * fp );

 

The fgetc() function reads a character from the input file referenced by fp. The return value is the character read, or in case of any error it returns EOF. The following functions allow you to read a string from a stream:

 

char *fgets( char *buf, int n, FILE *fp );

 

The functions fgets() reads up to n - 1 characters from the input stream referenced by fp. It copies the read string into the buffer buf, appending a null character to terminate the string.

 

If this function encounters a newline character '\n' or the end of the file EOF before they have read the maximum number of characters, then it returns only the characters read up to that point including new line character. You can also use int fscanf(FILE *fp, const char *format,

...) function to read strings from a file but it stops reading after the first space character encounters.

 

#include <stdio.h> main()

{

 

FILE *fp;

char buff[255];

 

fp = fopen("/tmp/test.txt", "r"); fscanf(fp, "%s", buff); printf("1 : %s\n", buff ); fgets(buff, 255, (FILE*)fp); printf("2: %s\n", buff ); fgets(buff, 255, (FILE*)fp); printf("3: %s\n", buff ); fclose(fp);

 

}

 

When the above code is compiled and executed, it reads the file created in previous section and produces the following result:

 

1 : This

 

2: is testing for fprintf...

 

3: This is testing for fputs...

 

Let's see a little more detail about what happened here. First fscanf() method read just this because after that it encountered a space, second call is for fgets() which read the remaining line till it encountered end of line. Finally last call fgets() read second line completely.

 

Binary I/O Functions

 

There are following two functions, which can be used for binary input and output:

 

size_t fread(void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);

 

size_t fwrite(const void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);

 

Both of these functions should be used to read or write blocks of memories - usually arrays or structures.

 

Now for our first program that reads from a file. This program begins with the familiar include, some data definitions, and the file opening statement which should require no explanation except for the fact that an r is used here because we want to read it.

#include <stdio.h> main( )

 

{

 

FILE *fp; char c;

 

funny = fopen("TENLINES.TXT", "r"); if (fp == NULL)

printf("File doesn't exist\n");

 

else { do {

 

c = getc(fp); /* get one character from the file */

 

putchar(c); /* display it on the monitor */

 

} while (c != EOF); /* repeat until EOF (end of file) */

 

}

fclose(fp);

 

}

 

In this program we check to see that the file exists, and if it does, we execute the main

 

body of the program. If it doesn’t, we print system will set the pointer equal to NULL which we can test. The main body of the program is one

 

do while loop in which a single character is read from the file and output to the monitor until an EOF (end of file) is detected from the input file. The file is then closed and the program is terminated. At this point, we have the potential for one of the most common and most perplexing problems of programming in C. The variable returned from the getc function is a character, so we can use a char variable for this purpose. There is a problem that could develop here if we happened to use an unsigned char however, because C usually returns a minus one for an EOF –which an unsigned char type variable is not

 

capable of containing. An unsigned char type variable can only have the values of zero to 255, so it will return a 255 for a minus one in C. This is a very frustrating problem to try to find. The program can never find the EOF and will therefore never terminate the loop. This is easy to prevent: always have a char or int type variable for use in returning an EOF. There is another problem with this program but we will worry about it when we get to the next program and solve it with the one following that.

 

After you compile and run this program and are satisfied with the results, it would be a good exercise to change the name of TENLINES.TXT and run the program again to see that the NULL test actually works as stated. Be sure to change the name back because we are still not finished with TENLINES.TXT.

 

Opening Files

 

You can use the fopen( ) function to create a new file or to open an existing file, this call will initialize an object of the type FILE, which contains all the information necessary to control the stream. Following is the prototype of this function call:

FILE *fopen( const char * filename, const char * mode );

 

Here, filename is string literal, which you will use to name your file and access mode can have one of the following values:

 

Mode Description r Opens an existing text file for reading purpose.


 

w Opens a text file for writing, if it does not exist then a new file is created. Here your program will start writing content from the beginning of the file.

 

a Opens a text file for writing in appending mode, if it does not exist then a new file is created. Here your program will start appending content in the existing file content.

 

r+ Opens a text file for reading and writing both.

 

w+  Opens a text file for reading and writing both. It first truncate the file to zero length if it exists otherwise create the file if it does not exist.

 

a+ Opens a text file for reading and writing both. It creates the file if it does not exist. The reading will start from the beginning but writing can only be appended.

 

If you are going to handle binary files then you will use below mentioned access modes instead of the above mentioned:

 

"rb", "wb", "ab", "ab+", "a+b", "wb+", "w+b", "ab+", "a+b"

 

Closing a File

 

To close a file, use the fclose( ) function. The prototype of this function is:

 

int fclose( FILE *fp );

 

The fclose( ) function returns zero on success, or EOF if there is an error in closing the file. This function actually, flushes any data still pending in the buffer to the file, closes the file, and releases any memory used for the file. The EOF is a constant defined in the header file stdio.h.

 

There are various functions provide by C standard library to read and write a file character by character or in the form of a fixed length string. Let us see few of the in the next section.

 

Writing a File

 

Following is the simplest function to write individual characters to a stream:

 

int fputc( int c, FILE *fp );

 

The function fputc() writes the character value of the argument c to the output stream referenced by fp. It returns the written character written on success otherwise EOF if there is an error. You can use the following functions to write a null-terminated string to a stream:

int fputs( const char *s, FILE *fp );

 

The function fputs() writes the string s to the output stream referenced by fp. It returns a non-negative value on success, otherwise EOF is returned in case of any error. You can use int fprintf(FILE *fp,const char *format, ...) function as well to write a string into a file. Try the following example:

 

#include <stdio.h>

 

main()

 

{

FILE *fp;

 

fp = fopen("/tmp/test.txt", "w+"); fprintf(fp, "This is testing for fprintf...\n"); fputs("This is testing for fputs...\n", fp); fclose(fp);

 

}

 

When the above code is compiled and executed, it creates a new file test.txt in /tmp directory and writes two lines using two different functions. Let us read this file in next section.

 

 

 

 

Reading a File

 

Following is the simplest function to read a single character from a file:

 

int fgetc( FILE * fp );

 

The fgetc() function reads a character from the input file referenced by fp. The return value is the character read, or in case of any error it returns EOF. The following functions allow you to read a string from a stream:

 

char *fgets( char *buf, int n, FILE *fp );

 

The functions fgets() reads up to n - 1 characters from the input stream referenced by fp. It copies the read string into the buffer buf, appending a null character to terminate the string.

 

If this function encounters a newline character '\n' or the end of the file EOF before they have read the maximum number of characters, then it returns only the characters read up to that point including new line character. You can also use int fscanf(FILE *fp, const char *format,

 

...) function to read strings from a file but it stops reading after the first space character encounters.

 

#include <stdio.h>

 

main()

{

FILE *fp;

 

char buff[255];

 

fp = fopen("/tmp/test.txt", "r"); fscanf(fp, "%s", buff); printf("1 : %s\n", buff ); fgets(buff, 255, (FILE*)fp); printf("2: %s\n", buff ); fgets(buff, 255, (FILE*)fp); printf("3: %s\n", buff ); fclose(fp);

}

 

When the above code is compiled and executed, it reads the file created in previous section and produces the following result:

 

1 : This

 

2: is testing for fprintf...

3: This is testing for fputs...

 

Let's see a little more detail about what happened here. First fscanf() method read just this because after that it encountered a space, second call is for fgets() which read the remaining line till it encountered end of line. Finally last call fgets() read second line completely.

 

 

 

 

Binary I/O Functions

 

There are following two functions, which can be used for binary input and output:

 

size_t fread(void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);

 

size_t fwrite(const void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);

 

Both of these functions should be used to read or write blocks of memories - usually arrays or structures.

 

1.     Redirection:

 

One way to get input into a program or to display output from a program is to use standard input and standard output , respectively. All that means is that to read in data, we use scanf() (or a few other functions) and to write out data, we use printf().

 

When we need to take input from a file (instead of having the user type data at the keyboard) we can use input redirection:

 

% a.out < inputfile

 

This allows us to use the same scanf() calls we use to read from the keyboard. With input redirection, the operating system causes input to come from the file (e.g., inputfile above) instead of the keyboard.

 

Similarly, there is output redirection :

 

% a.out > outputfile

 

that allows us to use printf() as before, but that causes the output of the program to go to a file (e.g., outputfile above) instead of the screen.

 

Of course, the 2 types of redirection can be used at the same time.

 

% a.out < inputfile > outputfile

 

 

 

 

 

 

2.     C File I/O:

 

While redirection is very useful, it is really part of the operating system (not C). In fact, C has a general mechanism for reading and writing files, which is more flexible than redirection alone.

 

stdio.h

There are types and functions in the library stdio.h that are used for file I/O. Make sure you always include that header when you use files.

Type

For files you want to read or write, you need a file pointer, e.g.:

 

FILE *fp;

 

What is this type "FILE *"? Realistically, you don't need to know. Just think of it as some abstract data structure, whose details are hidden from you. In other words, the only way you can use a FILE * is via the functions that C gives you.

 

Note: In reality, FILE is some kind of structure that holds information about the file. We must use a FILE * because certain functions will need to change that information, i.e., we

 

need to pass the information around by reference .

Functions

 

Reading from or writing to a file in C requires 3 basic steps:

 

1.     Open the file.

2.     Do all the reading or writing.

 

3.     Close the file.

 

Following are described the functions needed to accomplish each step.

 

3.     Opening a file:

 

In order to open a file, use the function fopen(). Use it as:

 

fp = fopen( filename , mode );

 

where:

o        filename is a string that holds the name of the file on disk (including a      path like           /cs/course if necessary).

o        mode is a string representing how you want to open the file. Most often you'll open a file for reading ("r") or writing ("w").

Note that fopen() returns a FILE * that can then be used to access the file. When the file cannot be opened (e.g., we don't have permission or it doesn't exist when opening for reading), fopen() will return NULL.

 

Here are examples of opening files:

 

FILE *ifp, *ofp; char *mode = "r";

char outputFilename[] = "out.list";

 

ifp = fopen("in.list", mode);

 

if (ifp == NULL) {

 

fprintf(stderr, "Can't open input file in.list!\n"); exit(1);

 

}

 

ofp = fopen(outputFilename, "w");

 

if (ofp == NULL) {

 

fprintf(stderr, "Can't open output file %s!\n", outputFilename);

exit(1);

 

}

 

Note that the input file that we are opening for reading ("r") must already exist. In contrast, the output file we are opening for writing ("w") does not have to exist. If it doesn't, it will be created. If this output file does already exist, its previous contents will be thrown away (and will be lost).

 

Note: There are other modes you can use when opening a file, such as append ("a") to append something to the end of a file without losing its contents...or modes that allow you to both read and write. You can look up these other modes in a good C reference on stdio.h.

 

Reading from or writing to a file:

 

Once a file has been successfully opened, you can read from it using fscanf() or write to it using fprintf(). These functions work just like scanf() and printf(), except they require an extra first parameter, a FILE * for the file to be read/written.

 

Note: There are other functions in stdio.h that can be used to read or write files. Look them up in a good C reference.

 

Continuing our example from above, suppose the input file consists of lines with a username and an integer test score , e.g.:

in.list

 

------

 

foo 70 bar 98

...

and that each username is no more than 8 characters long.

 

We might use the files we opened  above by copying each username and score from the input file to the output file. In the process, we'll increase each score by 10 points for the output file:

 

char username[9]; /* One extra for nul char. */ int score;

 

...

 

while (fscanf(ifp, "%s %d", username, &score) != EOF) { fprintf(ofp, "%s %d\n", username, score+10);

}

 

...

 

The function fscanf(), like scanf(), normally returns the number of values it was able to read in. However, when it hits the end of the file, it returns the special value EOF. So, testing the return value against EOF is one way to stop the loop.

 

The bad thing about testing against EOF is that if the file is not in the right format (e.g., a letter is found when a number is expected):

 

in.list

 

------

 

foo 70 bar 98 biz A+

 

...

 

then fscanf() will not be able to read that line (since there is no integer to read) and it won't advance to the next line in the file. For this error, fscanf() will not return EOF (it's not at the end of the file)....

 

 

 

Errors like that will at least mess up how the rest of the file is read. In some cases,

 

they will cause an infinite loop .

 

One solution is to test against the number of values we expect to be read by fscanf() each time. Since our format is "%s %d", we expect it to read in 2 values, so our condition could be:

 

while (fscanf(ifp, "%s %d", username, &score) == 2) {

 

Now, if we get 2 values, the loop continues. If we don't get 2 values, either because we are at the end of the file or some other problem occurred (e.g., it sees a letter when it is trying to read in a number with %d), then the loop will end.

 

Another way to test for end of file is with the library function feof(). It just takes a file pointer and returns a true/false value based on whether we are at the end of the file.

 

To use it in the above example, you would do:

 

while (!feof(ifp)) {

 

if (fscanf(ifp, "%s %d", username, &score) != 2) break;

fprintf(ofp, "%s %d", username, score+10);

 

}

 

Note that, like testing != EOF, it might cause an infinite loop if the format of the input file was not as expected. However, we can add code to make sure it reads in 2 values

 

Note: When you use fscanf(...) != EOF or feof(...), they will not detect the end of the file until they try to read past it. In other words, they won't report end-of-file on the last valid read, only on the one after it.

 

Closing a file:

 

When done with a file, it must be closed using the function fclose().

 

To finish our example, we'd want to close our input and output files:

 

fclose(ifp);

 

fclose(ofp);

 

Closing a file is very important, especially with output files. The reason is that

 

output is often buffered . This means that when you tell C to write something out, e.g., fprintf(ofp, "Whatever!\n");

it doesn't necessary get written to disk right away, but may end up in a This output buffer would hold the text temporarily:

 

buffer in memory.

 

Sample output buffer:

----------------------------------------------

| a | b | c | W | h | a | t | e | v | e | r |

 

----------------------------------------------

| ! | \n |  |  |  |  |  |  |  |  |  |

 

----------------------------------------------

|  |   |  |  |  |  |  |  |  |  |  |

 

----------------------------------------------

|  |   |  |  |  |  |  |  |  |  |  |

 

----------------------------------------------

 

...

 

(The buffer is really just 1-dimensional despite this drawing.)

When the buffer fills up (or when the file is closed ), the data is finally written to disk.

So, if you forget to close an output file then whatever is still in the buffer may not be written out.

 

Note: There are other kinds of buffering than the one we describe here.

 

Special file pointers:

 

There are 3 special FILE *'s that are always defined for a program. They are stdin ( standard input ), stdout ( standard output ) and stderr ( standard error ).

 

Standard Input

Standard input is where things come from when you use scanf(). In other words,

 

scanf("%d", &val);

 

is equivalent to the following fscanf():

 

fscanf(stdin, "%d", &val);

 

 

Standard Output

Similarly, standard output is exactly where things go when you use printf(). In other words,

 

printf("Value = %d\n", val):

 

is equivalent to the following fprintf():

 

fprintf(stdout, "Value = %d\n", val):

 

Remember that standard input is normally associated with the keyboard and standard output with the screen, unless redirection is used.

 

 

Standard Error

 

Standard error is where you should display error messages. We've already done that above:

 

fprintf(stderr, "Can't open input file in.list!\n");

 

Standard error is normally associated with the same place as standard output; however, redirecting standard output does not redirect standard error.

 

For example,

 

% a.out > outfile

only redirects stuff going to standard output to the file outfile... anything written to standard error goes to the screen.

 

Using the Special File Pointers

We've already seen that stderr is useful for printing error messages, but you may be

 

asking, "When would I ever use the special file pointers stdin and stdout ?" Well, suppose you create a function that writes a bunch of data to an opened file that is specified as a parameter:

 

 

 

 

void WriteData(FILE *fp)

 

{

 

fprintf(fp, "data1\n"); fprintf(fp, "data2\n");

...

 

}

 

 

 

 

Certainly, you can use it to write the data to an output file (like the one above):

 

WriteData(ofp);

 

But, you can also write the data to standard output:

WriteData(stdout);Without the special file pointer stdout , you'd have to write a second version of WriteData() that wrote stuff to standard output.

 


Study Material, Lecturing Notes, Assignment, Reference, Wiki description explanation, brief detail


Copyright © 2018-2020 BrainKart.com; All Rights Reserved. Developed by Therithal info, Chennai.