File handling in C

File handling in C is an essential concept that allows programmers to create, read, write, and manage files directly from their programs. This functionality is necessary for developing software that can store data persistently and beyond the lifecycle of a single program execution. Below, we will discuss file handling in C, including its uses, functions, and examples.

Introduction to File Handling in C

File handling in C involves various operations that a program can perform on files, including:

• Creating new files
• Opening existing files
• Reading from files
• Writing to files
• Closing files

C  Programming provides a set of standard I/O functions defined in the stdio.h library to manage files. Using the string Input/Output (I/O) function, data can be read from a file or written to a file in the form of an array of characters.

 

File Types in C

C programming recognizes two main types of files:

• Text Files: These files contain human-readable characters and are usually organized as lines of text, ending with newline characters (\n).
• Binary Files: These files contain data in a format not intended for human reading, often representing data in binary form for efficient storage and retrieval.

File Pointers

In C, file operations are managed through file pointers. A file pointer is a pointer of type FILE, which is defined in the stdio.h header file. A file pointer keeps track of the current position in the file and allows the program to read or write from that location.

Functions for File Handling in C

C programming provides a number of built-in functions to perform basic file operations. Here is an overview of essential functions for file handling in c:

a. fopen()

• Prototype: FILE *fopen(const char *filename, const char *mode);
• Description: Opens a file with a specified mode (e.g., reading, writing).
• Modes:
  • "r": Open for reading. The file must exist.
  • "w": Open for writing. Creates a new file or truncates an existing file.
  • "a": Open for appending. Adds data to the end of the file or creates a new file.
  • "r+": Open for both reading and writing. The file must exist.
  • "w+": Open for both reading and writing. Creates a new file or truncates an existing file.
  • "a+": Open for both reading and appending. Creates a new file if it does not exist.

Example:

FILE *filePtr;
filePtr = fopen(“example.txt”, “r”);
if (filePtr == NULL) {
printf(“Error opening file!\n”);
return 1;
}

 

b. fclose()

• Prototype: int fclose(FILE *stream);
• Description: Closes the file associated with stream. This function should always be called after finishing operations on a file to release resources.
• Return Value: Returns 0 if successful, EOF if an error occurs.

Example:

c. fgetc()

• Prototype: int fgetc(FILE *stream);
• Description: Reads a single character from the file pointed to by stream.
• Return Value: The character read as an int, or EOF if the end of the file is reached or an error occurs.

Example:

char ch;
ch = fgetc(filePtr);
while (ch != EOF) {
printf(“%c”, ch);
ch = fgetc(filePtr);
}

d. fputc()

• Prototype: int fputc(int char, FILE *stream);
• Description: Writes a single character to the file pointed to by stream.
• Return Value: The character is written as an int, or EOF if an error occurs.

Example:

fputc(‘A’, filePtr);

e. fgets()

• Prototype: char *fgets(char *str, int n, FILE *stream);
• Description: Reads a string from the file up to n-1 characters or until a newline or EOF is encountered. Adds a null terminator to the end of the string.
• Return Value: Returns str on success, or NULL on failure.

Example:

char buffer[100];
fgets(buffer, 100, filePtr);
printf(“%s”, buffer);

f. fputs()

• Prototype: int fputs(const char *str, FILE *stream);
• Description: Write a string to the file.
• Return Value: A non-negative number on success, EOF on failure.

Example:

fputs(“Hello, world!”, filePtr);

g. fprintf() and fscanf()

• fprintf(): Works like printf() but outputs formatted data to a file.
  • Prototype: int fprintf(FILE *stream, const char *format, ...);
• fscanf(): Works like scanf() but reads formatted data from a file.
  • Prototype: int fscanf(FILE *stream, const char *format, ...);

Example:

fprintf(filePtr, “Name: %s Age: %d\n”, “John”, 25);
fscanf(filePtr, “%s %d”, name, &age);

 

Working with Binary Files

C provides special functions for handling binary files:

a. fread()

• Prototype: size_t fread(void *ptr, size_t size, size_t count, FILE *stream);
• Description: Reads count elements of size bytes each from the file into ptr.
• Return Value: Number of items successfully read.

Example:

int data[10];
fread(data, sizeof(int), 10, filePtr);

b. fwrite()

• Prototype: size_t fwrite(const void *ptr, size_t size, size_t count, FILE *stream);
• Description: Writes count elements of size bytes each from ptr to the file.
• Return Value: Number of items successfully written.

Example:

fwrite(data, sizeof(int), 10, filePtr);

 

Error of File Handling in C

It is important to handle potential errors while working with files. The ferror() function checks if an error occurred during file operations.

• Prototype: int ferror(FILE *stream);
• Return Value: Non-zero if an error occurred; 0 otherwise.

Example:

if (ferror(filePtr)) {
printf(“An error occurred while reading the file.\n”);
}

Example of handling files in c programming

Reading and Writing to a Text File:

#include <stdio.h>

int main() {
FILE *filePtr;
// Open file for writing
filePtr = fopen(“example.txt”, “w”);
if (filePtr == NULL) {
printf(“Error opening file!\n”);
return 1;
}
// Write to the file
fprintf(filePtr, “Hello, this is a test.\n”);
fclose(filePtr);

// Open file for reading
filePtr = fopen(“example.txt”, “r”);
if (filePtr == NULL) {
printf(“Error opening file!\n”);
return 1;
}

char ch;
while ((ch = fgetc(filePtr)) != EOF) {
putchar(ch);
}
fclose(filePtr);

return 0;
}

Best Practices for File Handling in c

• Always check if a file was opened successfully.
• Close files with fclose() after completing operations to prevent memory leaks.
• Handle errors gracefully to make your program robust.
• Use binary mode when working with non-text data to prevent issues related to newline translation.

File handling in C is fundamental for any programmer looking to build applications that manage data outside the program’s runtime. Mastering these functions and practices will allow you to create powerful, data-driven applications with persistent storage capabilities.

Thank You!