CS156 FileIO: File I/O

I/O means Input/Output
File I/O means reading (input) and writing (output) files.

File I/O

The standard library provides utilities for reading and writing data files.
The functions are in the stdio.h header file.
A special data type, FILE *, is used to handle the I/O. It’s two words, kinda sorta.
The functions fopen and fclose manipulate this type and give us access to a file.

fopen

fopen takes two arguments and returns a handle:
handle = fopen(name, mode);
The name is a string containing the file’s name (path).
Might be a relative path, might be absolute.
The mode is a special string (not a char, even though it’s only one character long):
- "r" — open file for reading
- "w" — open file for writing

fclose

fclose takes one argument, the file handle returned by fopen:
fclose(handle);
If you successfully fopen it, you fclose it.
- If fopen failed (returned NULL), don’t call fclose.
fclose return an indication of whether the close succeeded, but it’s commonly ignored.
stdio.h defines some special constants:
- NULL — an empty pointer value
- EOF — a special number representing the end of a file

File I/O

Great—we know how to open & close the file. How do we actually, you know, read or write to it?

There are many functions that do file I/O. We will concentrate on a few: fgetc, fputc, fgets, and fputs
These functions all take, as an argument, the file handle returned by fopen. They do not take the filename—that’s only used by fopen.

File I/O functions

fgetc(handle) — gets a single character from a file. The special value EOF is returned if there is no more data.
fputc(char, handle) — puts one character into a file.
fgets(string, size, handle) — gets one line from a file an places it in the variable string.
fputs(string, handle) — writes a string to a file.

These functions keep track of where they are in the file. The first time that you call fgets, it reads the first line. The second time you call it, it reads the second line, etc.

Use the handle!

Only fopen uses the filename. The other functions use the handle, which is returned from fopen.
Yes, really.
Trust me on this.
Students seem to have a lot of trouble with this.
If you ask me about this, I will direct you to this slide.

Writing cat char-by-char

#include <stdio.h>
int main() {
    int c;            // An int, not a char.
    FILE *handle = fopen("data","r"); // open for reading
    // should test if fopen failed here
    while ((c = fgetc(handle)) != EOF)
        fputc(c, stdout);
    fclose(handle);
    return 0;
}
% c11 fgetscEx.c
% a.out
This is a test of the emergency broadcast system

fgetc and int

Why did we store the result of fgetc into an int?
Because fgetc has to return all possible characters, and the special value EOF. That means that fgetc’s value won’t fit into a char, so we have to upgrade it to an int.

Writing cat line-by-line

#include <stdio.h>
int main() {
    char buf[80];
    FILE *handle = fopen("data","r"); // open for reading
    // should test if fopen failed here
    while (fgets(buf, sizeof(buf), handle) != NULL)
        fputs(buf, stdout);
    fclose(handle);
    return 0;
}
% c11 fgetscEx.c
% a.out
This is a test of the emergency broadcast system

Example

#include <stdio.h>
int main() { 
    char line[100];     // store a line here
    FILE *in, *out;     // FILE object pointers
    in = fopen("infile","r");    // open for reading
    out = fopen("outfile","w");  // open for writing
    // should test if fopen failed here

    // read lines from the file until there are no more
    // fgets returns NULL if no more lines in file
    while (fgets(line,sizeof(line),in) != NULL)
        fputs(line,out); // print lines to outfile

    fclose(in);
    fclose(out);
    return 0;
}

Formatted File I/O

Two functions, fprintf and fscanf, allow formatted I/O with a file.
- fprintf(handle, format, param, …)
- count = fscanf(handle, format, &var, …)
  - count is the number of variables successfully read
    - Useful for error checking
- format is a standard printf-style format string
printf(format, param, …) ≡ fprintf(stdout, format, param, …)
scanf(format, &var, …) ≡ fscanf(stdin, format, &var, …)

Example

    #include <stdio.h>
    int main() { 
        int a,b,c;
        FILE *in = fopen("infile","r");    // open for reading
        FILE *out = fopen("outfile","w");  // open for writing
        // should test if fopen failed here

        // read pairs of numbers from the file
        count = fscanf(in, "%d%d", &a, &b);
        while (count==2) {
            fprintf(out, "Sum: %d\n", a+b);
            count = fscanf(in, "%d%d", &a, &b);
        }

        fclose(in);
        fclose(out);
        return 0;
    }

I/O Buffering

Data is not written directly to a file when we call fputc, fputs, fprintf.
The data is written to a buffer, a temporary holding space, until the buffer is full. Then the buffer is written to the file all at once.
To force the buffer to be written to the file we can use the function fflush(handle);

Special Handles

stdio.h defines three special handles that are always open:
- stdin — open for reading from the standard input stream
- stdout — open for writing to standard output
- stderr — open for writing to standard error
These file objects can be used with any of the file I/O functions we have discussed.
Don’t fopen or fclose these—it’s done for you.
Don’t write to stdin or read from stdout.

I/O Error Checking

Error Checking — check if fopen returns NULL
Input Error Check:

FILE *handle = fopen(inFilename,"r");
if (handle == NULL) {
    fprintf(stderr, "can't open %s\n", inFilename);
    exit(2);
}

I/O Error Checking

    #include <stdio.h>
    int main() { 
        char line[100];
        FILE *in = fopen("innie", "r"); // open file to read
        if (in == NULL) {
            printf("Can't open input file \"innie\"\n");
            return 1;
        }
        FILE *out = fopen("outie", "w"); // open file to write
        if (out == NULL) {
            // Do NOT fclose(out), because it’s not open.
            fclose(in);
            printf("Can't open output file \"outie\"\n");
            return 2;
        } 
        // read lines until end of file
        while (fgets(line,sizeof(line),in) != NULL)
            fputs(line,out);     // write a line to outfile

        fclose(in);              // close the file
        fclose(out);             // close the file
        return 0;
    }

CS156: Intro to C, Part I

Spring 2018

File IO

CS156 FileIO: File I/O

File I/O

fopen

fclose

File I/O

File I/O functions

Use the handle!

Writing cat char-by-char

fgetc and int

Writing cat line-by-line

Example

Formatted File I/O

Example

I/O Buffering

Special Handles

I/O Error Checking

I/O Error Checking