A file represents a sequence of bytes, regardless of it being a text file or a binary file.

C
programming language provides access on high level functions as well as low level (OS
level) calls to handle file on your storage devices. This chapter will take you through the
important calls for file management.

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. The prototype of this function call is as follows −

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

Here, filename is a 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.

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

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

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

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

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

If you are going to handle binary files, then you will use following access modes instead of
the above mentioned ones −

"rb", "wb", "ab", "rb+", "r+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 provided by C standard library to read and write a file, character
by character, or in the form of a fixed length string.

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.

Make sure you have /tmp directory available. If it is not, then before proceeding, you must
create this directory on your machine.

#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 the next
section.

Reading a File
Given below 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 function allows
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 the 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
encountering the first space character.

#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);

fclose(fp);

When the above code is compiled and executed, it reads the file created in the 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 in detail about what happened here. First, fscanf() read just This
because after that, it encountered a space, second call is for fgets() which reads the
remaining line till it encountered end of line. Finally, the last call fgets() reads the second
line completely.

Recursion

If a program allows you to call a function inside the same function, then it is called a
recursive call of the function.

void recursion() {

recursion(); /* function calls itself */

int main() {

recursion();

The C programming language supports recursion, i.e., a function to call itself. But while
using recursion, programmers need to be careful to define an exit condition from the
function, otherwise it will go into an infinite loop.

Recursive functions are very useful to solve many mathematical problems, such as
calculating the factorial of a number, generating Fibonacci series, etc.

Number Factorial
The following example calculates the factorial of a given number using a recursive function
−
 #include <stdio.h>

int factorial(unsigned int i) {

if(i <= 1) {

return 1;

return i * factorial(i - 1);

int main() {

int i = 15;

printf("Factorial of %d is %d\n", i, factorial(i));

return 0;

When the above code is compiled and executed, it produces the following result −

Factorial of 15 is 2004310016

Fibonacci Series
The following example generates the Fibonacci series for a given number using a recursive
function −

#include <stdio.h>

int fibonaci(int i) {

if(i == 0) {

return 0;

if(i == 1) {

return 1;

return fibonaci(i-1) + fibonaci(i-2);

}
int main() {

int i;

for (i = 0; i < 10; i++) {

printf("%d\t\n", fibonaci(i));

return 0;