File handling in c

Your BCA Guide

Shortcuts

• Home
• About Developer

file handling in c language

---

File handling in the C programming language encompasses operations such as reading data from files, writing data to files, and managing file contents. Here's a detailed exploration of file handling in C:

file pointer

In the realm of C programming, a file pointer assumes a crucial role as it serves as a specialized pointer type specifically tailored to navigate and manage file operations. Essentially, a file pointer refers to a structure known as FILE, meticulously crafted within the standard input-output library (stdio.h). This FILE structure meticulously stores essential information pertinent to a file, including its current position, status indicators, and buffering specifics.

When dealing with file operations in C, the first step typically involves declaring a file pointer using the FILE data type. Here's an illustration demonstrating the process:

#include <stdio.h>
    int main() {
        FILE *filePtr; // Declaration of a file pointer
    
        filePtr = fopen("example.txt", "r"); // Opening a file and assigning its pointer to filePtr
    
        // Check if the filePtr is NULL, indicating an error in file opening
        if (filePtr == NULL) {
            printf("Encountered an error while opening the file.\n");
            return 1; // Terminate the program with an error status
        }
    
        // Conduct file handling operations within this block...
    
        fclose(filePtr); // Close the file once operations are complete
    
        return 0; // Return 0 to signify successful execution
    }
                                         
                

In the provided example:

--filePtr symbolizes the file pointer utilized within the program.
--The fopen() function is employed to initiate file opening, furnishing a pointer to the opened file. This pointer is subsequently assigned to filePtr.
--Upon completing file operations, the fclose() function is employed to gracefully close the file.
--File pointers, in conjunction with an array of file handling functions such as fscanf(), fprintf(), fgetc(), fputc(), among others, are instrumental in executing read and write operations on files, proficiently managing the current position within the file, thus facilitating efficient data manipulation.

---

buffer

In C file handling, a buffer serves as a temporary storage space utilized to temporarily hold data when reading from or writing to a file. Buffers play a crucial role in enhancing the efficiency of file operations by minimizing the number of system calls or I/O operations.

When reading from a file, data is typically first read into a buffer before being processed by the program. Similarly, when writing to a file, data is initially stored in a buffer before being transferred to the file. This buffering mechanism enables the program to accumulate a certain amount of data before executing actual read or write operations, significantly reducing the overhead associated with frequent I/O operations.

C inherently provides buffered I/O functionality for both reading and writing operations. When utilizing functions like fscanf(), fgets(), or fread() to read data from a file, or functions such as fprintf(), fputs(), or fwrite() to write data to a file, the C standard library implicitly manages buffering to optimize I/O performance.

However, explicit control over buffering is also feasible through functions like setvbuf() and fflush(). The setvbuf() function empowers you to specify the buffering mode (fully buffered, line buffered, or unbuffered) for a stream, while fflush() ensures that all buffered data is appropriately written out to the file by flushing the buffer.

Below is an illustration showcasing the use of buffered I/O in C file handling:

#include <stdio.h>
    int main() {
        FILE *filePtr;
        char dataBuffer[100];
    
        // Open the file in read mode
        filePtr = fopen("example.txt", "r");
        if (filePtr == NULL) {
            printf("Failed to open the file.\n");
            return 1;
        }
    
        // Read data into the buffer
        fgets(dataBuffer, sizeof(dataBuffer), filePtr);
        printf("Data retrieved from the file: %s\n", dataBuffer);
    
        // Close the file
        fclose(filePtr);
        return 0;
    }
    
                

In this example

--: the fgets() function is employed to read data from the file into the dataBuffer array.
--: The C library seamlessly manages buffering behind the scenes to optimize the read operation.

---

Opening Files

Files are accessed using the fopen() function, which returns a file pointer (FILE*) for subsequent file operations.

#include <stdio.h>
    int main() {
        FILE *filePointer;
    
        // Open a file in read mode
        filePointer = fopen("example.txt", "r");
        if (filePointer == NULL) {
            printf("Unable to open the file.\n");
            return 1;
        } else {
            printf("File opened successfully.\n");
        }
    
        // Close the file
        fclose(filePointer);
        return 0;
    }
                        
                

reading modes

In file handling within programming, file opening modes play a crucial role in dictating how files are accessed and manipulated by programs. These modes specify whether a file will be opened for reading, writing, appending, or a combination of these operations. Additionally, they provide options for handling file creation and determining whether the file will be opened in text or binary mode. Below are the primary file opening modes commonly used in C:

"r": This mode opens a file for reading. It requires the file to already exist, and if it cannot be opened for reading, the fopen() function returns NULL.

"w": In this mode, the file is opened for writing. If the file already exists, its contents are erased. If the file doesn't exist, a new one is created. This mode is often used for creating new files or overwriting existing ones.

"a": Opening a file in append mode allows data to be added to the end of the file. If the file doesn't exist, a new one is created. Existing file contents remain intact. "r+": This mode opens a file for both reading and writing. The file must already exist, and data can be read from and written to any part of it.

"w+": In "read and write" mode, the file is opened for both reading and writing. If the file exists, its contents are erased. If not, a new file is created.

"a+": Opening a file in "read and append" mode allows reading from any part of the file and writing only at the end. If the file doesn't exist, it will be created.

Additionally, "t" or "b" can be added to the mode string to specify whether the file should be opened in text or binary mode. For example, "rt" indicates reading a file in text mode, while "wb" denotes writing to a file in binary mode.

Here's a summary of the file opening modes:

"r": Open for reading.
"w": Open for writing, creating a new file or overwriting an existing one.
"a": Open for appending, creating a new file if it doesn't exist.
"r+": Open for reading and writing, file must exist.
"w+": Open for reading and writing, creating a new file or overwriting an existing one.
"a+": Open for reading and appending, creating a new file if it doesn't exist.

Understanding these file opening modes is essential for performing file operations in C programming efficiently.

---

Reading from Files

Data can be read from files using functions like fscanf() or fgets().

#include <stdio.h>
  int main() {
      FILE *filePointer;
      char buffer[100];
  
      filePointer = fopen("example.txt", "r");
      if (filePointer == NULL) {
          printf("Unable to open the file.\n");
          return 1;
      }
  
      // Read data from the file
      fscanf(filePointer, "%s", buffer);
      printf("Data read from the file: %s\n", buffer);
  
      fclose(filePointer);
      return 0;
  }
                    
                

---

Writing to Files

Data can be written to files using functions like fprintf() or fputs()

#include <stdio.h>
  int main() {
      FILE *filePointer;
  
      filePointer = fopen("output.txt", "w");
      if (filePointer == NULL) {
          printf("Unable to open the file.\n");
          return 1;
      }
  
      // Write data to the file
      fprintf(filePointer, "Hello, World!\n");
  
      fclose(filePointer);
      return 0;
  }
                    
                

---

Error Handling

Error handling is crucial during file operations. Most file handling functions return NULL on failure.

FILE *filePointer;
filePointer = fopen("example.txt", "r");
if (filePointer == NULL) {
    printf("Failed to open the file.\n");
    return 1;
}
                  
                

---

Closing Files

After completing file operations, it's essential to close the file using the fclose() function.

fclose(filePointer);
                

---

example: File Content Copying

Below is an example that reads content from one file and writes it to another:

#include <stdio.h>
  int main() {
      FILE *sourceFile, *destinationFile;
      char character;
  
      sourceFile = fopen("source.txt", "r");
      if (sourceFile == NULL) {
          printf("Failed to open the source file.\n");
          return 1;
      }
  
      destinationFile = fopen("destination.txt", "w");
      if (destinationFile == NULL) {
          printf("Failed to open the destination file.\n");
          fclose(sourceFile);
          return 1;
      }
                    
                        while ((character = fgetc(sourceFile)) != EOF) {
                            fputc(character, destinationFile);
                        }
                    
                        fclose(sourceFile);
                        fclose(destinationFile);
                    
                        printf("File copied successfully.\n");
                    
                        return 0;
                    }
                    
                

This program copies the content of a file named "source.txt" to another file named "destination.txt". Here's the step-by-step explanation of the program:

It declares two file pointers, sourceFile and destinationFile, and a character variable character.
It attempts to open "source.txt" in read mode "r" and "destination.txt" in write mode "w".
If either of the file openings fails (i.e., the file pointers are NULL), it prints an error message and exits the program with a return value of 1.
If both files are successfully opened, it reads characters from "source.txt" using fgetc() in a loop until EOF (end of file) is encountered.
Inside the loop, each character read from "source.txt" is written to "destination.txt" using fputc().
Once the loop finishes, it closes both files using fclose().
Finally, it prints "File copied successfully" and returns 0, indicating successful execution.
Given this, if "source.txt" contains the text "Hello, World!", the program will copy this text to "destination.txt". The output on the console will be:

File copied successfully.
                

---

feof(), fseek(), and rewind()

feof() (File End-of-File):
--: feof() is a function utilized to assess whether the end-of-file (EOF) marker has been reached for a particular file stream.
--: Its return value indicates the status of the EOF marker: non-zero if it's set, indicating the end of the file, and 0 if it's not set, signifying more data remains to be read.
--: This function is commonly paired with file reading functions like fscanf(), fgets(), or fgetc() to ascertain if the file's end has been reached.

fseek() (File Seek):
--: The purpose of fseek() is to relocate the file position indicator to a specific position within a file.
--: It offers control over where the subsequent read or write operation will occur.
--: The syntax for fseek() is: int fseek(FILE *stream, long int offset, int origin);
stream: File pointer pointing to the file.
offset: Number of bytes by which to move the file pointer.
origin: Defines the reference point for the offset, using values like SEEK_SET, SEEK_CUR, or SEEK_END.
A return value of 0 indicates success, while a non-zero value signifies failure.

rewind():
--: rewind() is a function designated to reset the file position indicator to the beginning of the file.
--: It essentially sets the file pointer to the start, akin to calling fseek() with an offset of 0 from the file's beginning.
--: This function is commonly employed when re-reading the file contents from the start is required.
Now, let's illustrate their usage with an example:

                  
#include <stdio.h>
 int main() {
     FILE *file_ptr;
     char character;
 
     // Open file in read mode
     file_ptr = fopen("example.txt", "r");
     if (file_ptr == NULL) {
         printf("Failed to open the file.\n");
         return 1;
     }
 
     // Read characters from the file until EOF is reached
     while (!feof(file_ptr)) {
         character = fgetc(file_ptr);
         if (!feof(file_ptr)) {
             printf("%c", character);
         }
     }
 
     // Reset the file pointer to the beginning of the file
     fseek(file_ptr, 0, SEEK_SET);
 
     // Alternatively, you can use rewind() to achieve the same result
     // rewind(file_ptr);
 
     // Perform additional file operations...
 
     // Close the file
     fclose(file_ptr);
 
     return 0;
 }
                    
                

we've explained the functions feof(), fseek(), and rewind() in a distinct manner, along with an example demonstrating their usage.

---