Programming in C

Lecture Outline

Aims and Objectives
Files
Before a File can be Opened...
Closing Files
Reading from a stream
Writing to a stream
Reading from Standard Input

Aims and Objectives

• File Pointers

• Opening and Closing Files

• Reading from and writing to files

• Reading from stdin and writing to stdout, stderr

• Moving the file pointer

• File errors and utilities

• Files in C are just arbitrary byte streams

• There are several ways of reading from and writing to files, but we'll look at the simplest way - reading and writing a byte at a time...

• There are a maximum number of files that can be open at any one time, so closing files when you are done with them is very important

• We'll also see that stdin, stdout and stderr are special files which C opens automatically

• We'll take a look at how file pointers can be manipulated, so that we can move backwards and forwards through an open file

• We'll finish off with some utilities which can be used to obtain information about files, and how to detect and handle file errors

Before a File can be Opened...

• Like anything else in C, before you can manipulate a file you must declare it

• Files are declared by declaring a File Handle, which is a pointer to FILE

  	FILE *fp;

• This creates a pointer in memory which will contain the address of a memory location through which the file can be communicated with

• We can consider this area to be a file buffer, leaving to the Operating System the particulars of how the file is physically read from and written to

• As usual, fp will initially contain garbage

• We create a File Handle by fopening a file

  	fp = fopen(const char *filename, const char *mode);

  filename is a character string representing the file name. The full pathname of the file must be given if the file is not in the same directory as the executable

  mode is one of the following character strings

  "r": read only
  "w": write only - file is created if it doesn't exist. File is truncated to zero length
  "a": Append - write to file from EOF
  "r+": Read and write
  "w+": Truncate file to zero length and then allow read and write
  "a+": Same as "r+", but write at EOF

• If fopen() is successful, then fp will contain the address through which the contents of the file can be manipulated (it will be a stream)

• If fopen() fails then fp will be NULL

• fopen() can fail if the file is opened for reading and the file does not exist, or if the process does not have sufficient permissions to open the file in the specified mode

• We'll look at fopen() errors later...

Closing Files

• Files can be closed using

  fclose(FILE *stream);

• fclose() will return 0 if the stream was closed successfully, otherwise it will return EOF

• We'll see later how to find out what problem occurred if fclose() returns EOF

Reading from a stream

int fgetc(FILE *stream);
• fgetc() reads a character from the stream, converting it to an int in the process (so that it is the ASCII value of the character)

• fgetc() returns EOF when the end-of-file is encountered

• EOF may not be detected if the data just read is stored in a char!!!

  	char c;
  	FILE *fp;
  
  	fp = fopen("filename", "r");
  	
  	do 
  	{
  		c = fgetc(fp);
  	} while (c != EOF);
  	

  ... which is why in my earlier examples for getchar() and putchar() I used int c...

• fgetc() return EOF whenever an error occurs...

• fgetc() will fail if the file has not been opened for reading/updating, or if the process tries to read beyond the EOF marker, or before the beginning of the file

• fgetc() can also fail if there is a hardware error

• ferror() and feof() must be used to distinguish between an error occurring and EOF being encountered

• We'll look at these functions later...

Writing to a stream

int fputc(int c, FILE *stream);
• fputc() writes c to the stream

• fputc() returns the character just written if the write was successful, and EOF otherwise

• fputc() will be unsuccessful if the file is not open for writing, or if the file cannot grow, or if a hardware error occurs

• More about the errors and how to handle them later...

Exercise

Write the program filecopy to read from one file, writing each character read to another file

Reading from Standard Input

• Whenever a C program executes, three files are automatically opened for the process

  stdin: Standard input
  stdout: standard output
  stderr: Standard error
  

• They are already streams, so you can read from stdin...

  fgetc(stdin)

• ... write to stdout...

  fputc(stdout)

• ... and write to stderr

  fputc(stderr)

• stdin, stdout, and stderr are defined in stdio.h

• You can therefore create your own handles for these streams, using user determined files if these have been provided, and the standard files otherwise.

  	FILE *fp;
  
  	if (user_input_file == NULL) {
  		fp = stdin;
  	} else {
  		fp = fopen(user_input_file, "r");
  	}
  	
  	// remember to check status of fp!
  
  	if (!fp) {
  		handle_fp_error();
  		exit(1);
  	}
  	

Exercise 2

Modify the filecopy program to copy data from a named file, if it has been specified, or else from stdin. Have your program take the name of the file from the command line, using -i as the option.

filecopy -i infile

will use infile as the input file, but

filecopy

will take data from the keyboard through stdin