Back to DFS's C Page

In order to work with a disk file, a pointer to a file I/O structure must be initialized. The structure definition, _IO_FILE, can be found in libio.h in the include directory, /usr/include on Linux, but you do not need to know the information that is stored in the structure -- you do not manipulate this structure directly. Rather, you pass arguments to the system function fopen() to indicate how the file will be dealt with. Numerous functions are available for reading from and writing to the file. When you are done with a file, you use the system function fclose() to terminate access.

Sample code is also provided.

To open a file, you must have a pointer variable to the _IO_FILE structure declared in your program. This example uses fpin, an abbreviation for File Pointer for INput.

FILE *fpin;

FILE is defined in stdio.h (which includes libio.h) using the following typedef:

typedef struct _IO_FILE FILE;

This usage of FILE makes program code more portable, because the structure can be defined differently for different operating systems. As a companion to this, making things truly portable, the programmer uses the system I/O functions whose prototypes are specified in stdio.h.

Back to Top

Opening a file is handled using the system function fopen(), which takes two arguments: the filename (including the full path) and the read/write permissions. The following fragment attempts to open for reading a file whose name is stored in the string variable inputfile.

if( (fpin = fopen(inputfile, "r")) == NULL)
{
   /* error-handling code */
   printf("Problem opening file %s.\n", inputfile);
   /* more instructions may be added */
} 

The "r" is one of the file-access modes provided in the accompanying table.

Good Programming Practice: Use a string variable to store the path and name of the file, instead of hard-coding the name of the file into the fopen() call. This makes it easier to change the program later to allow the user to specify a file of his choice.

File-Access Modes

Back to Top

The functions used for reading and writing data are different for variable- and fixed-length records. This info has been gleaned from the man pages.

• Reading Data
  • fgetc() reads the next character from stream and returns it as an unsigned char cast to an int, or EOF on end of file or error.
    Synopsis:
    int fgetc(FILE *stream);
  • fgets() reads in at most one less than size characters from stream and stores them into the buffer pointed to by s. Reading stops after an EOF or a newline. If a newline is read, it is stored into the buffer. A '\0' is stored after the last character in the buffer.
    Synopsis:
    char *fgets(char *s, int size, FILE *stream);
  • fscanf() reads input from the stream pointer stream. See the scanf() page for conversion details.
    Synopsis:
    int fscanf( FILE *stream, const char *format, ...);
• Writing Data
  • fputc() writes the character c, cast to an unsigned char, to stream.
    Synopsis:
    int fputc(int c, FILE *stream);
  • fputs() writes the string s to stream, without its trailing '\0'.
    Synopsis:
    int fputs(const char *s, FILE *stream);
  • fprintf() writes output to the given output stream. See the printf() page for details.
    Synopsis:
    int fprintf( FILE *stream, const char *format, ...);

To get information on this topic, use
man fseek
man fread
To be filled in at a later date...

• size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
• size_t fwrite( void *ptr, size_t size, size_t nmemb, FILE *stream);
• void rewind( FILE *stream);
• int fseek( FILE *stream, long offset, int whence);

Back to Top

Closing a file is handled using the system function fclose(), which takes a single argument: the pointer to the FILE struct. fclose() returns an int which can be one of two values: zero (0) or EOF. Zero indicates success; EOF means that the file could not be closed for some reason.

if( fclose(fpin) == EOF)
{
   /* error-handling code */
   printf("Problem closing file %s.\n", inputfile);
   /* more instructions may be added */
} 

Good Programming Practice: Always close a file as soon as you are done using it, even though the system may do housekeeping when your program exits. This frees up system resources and helps prevent accidental writing to a file.

Good Programming Practice: Always check for failure. A file which is opened for read-only may not pose a problem, but files being written to which cannot close can spell disaster.

Back to Top

The following program demonstrates how to access files for input and output. The purpose of the program is to create a copy of a file. N.B. There is no bulletproofing included.

/* Copy a file */
#include <stdio.h>

void main()
{
   int ch; /* input character */
   char inputfile[80], outputfile[80];
   FILE *fpin, *fpout; /* input & output struct pointers */

   /* get the filenames from the user */
   printf("What file do you want to copy? ");
   scanf("%s", inputfile);
   printf("What file name do you want for the copy? ");
   scanf("%s", outputfile);

   /* open the files */
   fpin = fopen(inputfile, "r");
   fpout = fopen(outputfile, "w");

   /* copy the file char by char */
   while( (ch = fgetc(fpin)) != EOF)
   {
      fputc(ch, fpout);
   }

   /* close the files */
   fclose(fpin);
   fclose(fpout);
}

Back to Top