Scribd
Upload
0 views

Files in C Programming

The document provides an overview of file handling in C programming, detailing the use of FILE pointers, the fopen function for opening files, and modes for reading, writing, and appending. It also covers functions for reading and writing characters (fgetc, fputc) and handling binary data (fread, fwrite), along with examples of their usage. Additionally, it explains error handling when opening files and the importance of using double backslashes in file paths.

Uploaded by

kisherno.webster
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
0 views

Files in C Programming

The document provides an overview of file handling in C programming, detailing the use of FILE pointers, the fopen function for opening files, and modes for reading, writing, and appending. It also covers functions for reading and writing characters (fgetc, fputc) and handling binary data (fread, fwrite), along with examples of their usage. Additionally, it explains error handling when opening files and the importance of using double backslashes in file paths.

Uploaded by

kisherno.webster
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 7

Files in C Programming

Additional information can be found in the texts,


Understanding Computer Science for Advanced
Level 3rd Edition Chapter 16 page 338 and C How
to Program 5th Edition Chapter 11 page 438.
When accessing files through C, the first necessity
is to have a way to access the files. For C File I/O
you need to use a FILE pointer, which will let the
program keep track of the file being accessed. (You
can think of it as the memory address of the file or
the location of the file).
For example:
FILE *fp;
To open a file you need to use the fopen function,
which returns a FILE pointer. Once you've opened a
file, you can use the FILE pointer to let the compiler
perform input and output functions on the file.
FILE *fopen(const char *filename, const char
*mode);
In the filename, if you use a string literal as the
argument, you need to remember to use double
backslashes rather than a single backslash as you
otherwise risk an escape character such as \t.
Using double backslashes \\ escapes the \ key, so
the string works as it is expected. Your users, of
course, do not need to do this! It's just the way
1
quoted strings are handled in C and C++.

The modes are as follows:


r - open for reading
w - open for writing (file need not exist)
a - open for appending (file need not exist)
r+ - open for reading and writing, start at
beginning
w+ - open for reading and writing (overwrite file)
a+ - open for reading and writing (append if file
exists)
Note that it's possible for fopen to fail even if your
program is perfectly correct: you might try to open
a file specified by the user, and that file might not
exist (or it might be write-protected). In those
cases, fopen will return 0, the NULL pointer.

Here's a simple example of using fopen:


FILE *fp;
fp=fopen("c:\\test.txt", "r");
This code will open test.txt for reading in text
mode. To open a file in a binary mode you must
add a b to the end of the mode string; for example,
"rb" (for the reading and writing modes, you can
2
add the b either after the plus sign - "r+b" - or
before - "rb+")

To close a function you can use the function


int fclose(FILE *a_file);
fclose returns zero if the file is closed successfully.

An example of fclose is
fclose(fp);
To work with text input and output, you use fprintf
and fscanf, both of which are similar to their
friends printf and scanf except that you must pass
the FILE pointer as first argument. For example:
FILE *fp;
fp=fopen("c:\\test.txt", "w");
fprintf(fp, "Testing...\n");
It is also possible to read (or write) a single
character at a time--this can be useful if you wish
to perform character-by-character input (for
instance, if you need to keep track of every piece
of punctuation in a file it would make more sense
to read in a single character than to read in a string
at a time.) The fgetc function, which takes a file
pointer, and returns an int, will let you read a
single character from a file:

3
int fgetc (FILE *fp);
Notice that fgetc returns an int. What this actually
means is that when it reads a normal character in
the file, it will return a value suitable for storing in
an unsigned char (basically, a number in the range
0 to 255). On the other hand, when you're at the
very end of the file, you can't get a character
value--in this case, fgetc will return "EOF", which is
a constant that indicates that you've reached the
end of the file. To see a full example using fgetc in
practice, take a look at the example here.

The fputc function allows you to write a character


at a time--you might find this useful if you wanted
to copy a file character by character. It looks like
this:
int fputc( int c, FILE *fp );
Note that the first argument should be in the range
of an unsigned char so that it is a valid character.
The second argument is the file to write to. On
success, fputc will return the value c, and on
failure, it will return EOF.
Binary I/O
For binary File I/O you use fread and fwrite.

The declarations for each are similar:

4
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 deal with blocks of
memories - usually arrays. Because they accept
pointers, you can also use these functions with
other data structures; you can even write structs to
a file or a read struct into memory.

Let's look at one function to see how the notation


works.

fread takes four arguments. Don't by confused by


the declaration of a void *ptr; void means that it is
a pointer that can be used for any type variable.
The first argument is the name of the array or the
address of the structure you want to write to the
file. The second argument is the size of each
element of the array; it is in bytes. For example, if
you have an array of characters, you would want to
read it in one byte chunks, so size_of_elements is
one. You can use the sizeof operator to get the size
of the various datatypes; for example, if you have
a variable int x; you can get the size of x with
sizeof(x);. This usage works even for structs or

5
arrays. E.g., if you have a variable of a struct type
with the name a_struct, you can use
sizeof(a_struct) to find out how much memory it is
taking up.

e.g.,
sizeof(int);

The third argument is simply how many elements


you want to read or write; for example, if you pass
a 100 element array, you want to read no more
than 100 elements, so you pass in 100.

The final argument is simply the file pointer we've


been using. When fread is used, after being passed
an array, fread will read from the file until it has
filled the array, and it will return the number of
elements actually read. If the file, for example, is
only 30 bytes, but you try to read 100 bytes, it will
return that it read 30 bytes. To check to ensure the
end of file was reached, use the feof function,
which accepts a FILE pointer and returns true if the
end of the file has been reached.

fwrite is similar in usage, except instead of reading


into the memory you write from memory into a file.

For example,

6
FILE *fp;
fp=fopen("c:\\test.bin", "wb");
char x[10]="ABCDEFGHIJ";
fwrite(x, sizeof(x[0]), sizeof(x)/sizeof(x[0]), fp);

You might also like