File Handling in C

File handling in C involves performing operations on files, such as creating, opening, reading, writing, and closing them. The standard library in C provides functions and data types to handle files.

To work with files in C, you need to include the <stdio.h> header file, which provides functions and macros for file handling.

Here’s a step-by-step guide on common file handling operations in C:

Opening a File:
- Use the fopen() function to open a file with a specified mode.
- The function prototype is: FILE* fopen(const char* filename, const char* mode);
- Example: FILE* file = fopen("example.txt", "r"); opens a file named “example.txt” in read mode.
Reading from a File:
- Use functions like fscanf(), fgets(), or fread() to read data from the file.
- Example:

char buffer[100];
fscanf(file, "%s", buffer); // Reads a string from the file

3. Writing to a File:

Use functions like fprintf(), fputs(), or fwrite() to write data to the file.
Example:

fprintf(file, "Hello, World!"); // Writes a string to the file

4. Closing a File:

- After finishing file operations, use the fclose() function to close the file and free system resources.
- Example: fclose(file);5. Error Handling:
  - Check the return values of file handling functions to detect errors.
  - Example:

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

It’s important to note that file paths can be relative or absolute. Relative paths are specified relative to the current working directory, while absolute paths provide the full path to the file.

Additionally, the “mode” parameter in fopen() specifies the intended file operation. Common modes include “r” (read), “w” (write), “a” (append), “rb” (read in binary mode), “wb” (write in binary mode), etc.

Remember to handle errors properly when working with files to ensure your program behaves as expected.

Functions for file handling:

Here are some commonly used functions for file handling in C:

FILE* fopen(const char* filename, const char* mode)
- Opens a file with the specified filename and mode.
- Returns a pointer to a FILE structure that represents the opened file or NULL on failure.
int fclose(FILE* stream)
- Closes the specified file stream.
- Returns 0 on success and EOF (End-of-File) on failure.
int fprintf(FILE* stream, const char* format, ...)
- Writes formatted data to the file stream.
- Returns the number of characters written or a negative value on failure.
int fscanf(FILE* stream, const char* format, ...)
- Reads formatted data from the file stream.
- Returns the number of input items successfully matched and assigned or EOF on failure or end-of-file condition.
int fgetc(FILE* stream)
- Reads a single character from the file stream.
- Returns the character read as an unsigned char cast to an int or EOF on failure or end-of-file condition.
int fputc(int character, FILE* stream)
- Writes a character to the file stream.
- Returns the character written as an unsigned char cast to an int or EOF on failure.
char* fgets(char* str, int num, FILE* stream)
- Reads a line from the file stream and stores it in the specified string.
- Returns the string on success or NULL on failure or end-of-file condition.
int fputs(const char* str, FILE* stream)
- Writes a string to the file stream.
- Returns a non-negative value on success or EOF on failure.
size_t fread(void* ptr, size_t size, size_t count, FILE* stream)
- Reads data from the file stream into the specified buffer.
- Returns the number of items read.
size_t fwrite(const void* ptr, size_t size, size_t count, FILE* stream)
- Writes data from the specified buffer to the file stream.
- Returns the number of items written.

These are just a few examples of functions for file handling in C. The <stdio.h> header file contains more functions and macros that can be used for various file-related operations.

Opening File: fopen()

The fopen() function in C is used to open a file and obtain a file pointer that can be used for subsequent file operations. Here’s the syntax of the fopen() function:

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

The filename parameter is a string that represents the name of the file to be opened, including the file path if necessary. It can be a relative or absolute path.

The mode parameter is also a string that specifies the intended mode of file access. Here are some commonly used modes:

“r”: Open for reading. The file must exist.
“w”: Open for writing. If the file exists, its contents are truncated. If the file does not exist, a new file is created.
“a”: Open for appending. Data is added to the end of the file. If the file does not exist, a new file is created.
“rb”, “wb”, “ab”: Similar to the above modes but for binary file access.

The fopen() function returns a pointer to a FILE structure that represents the opened file. This pointer is used for subsequent file operations. If the file cannot be opened, the function returns NULL.

Here’s an example that demonstrates the usage of fopen():

#include <stdio.h>

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

    // File operations...

    fclose(file);
    return 0;
}

In this example, the code attempts to open a file named “example.txt” in read mode. If the file is successfully opened, subsequent file operations can be performed. Finally, the file is closed using fclose() to release system resources.

Closing File: fclose()

The fclose() function in C is used to close a previously opened file. It ensures that any buffered data associated with the file is written to the disk and releases the system resources associated with the file.

Here’s the syntax of the fclose() function:

int fclose(FILE* stream);

The stream parameter is a pointer to the FILE structure that represents the file to be closed.

The fclose() function returns an integer value indicating the success or failure of the operation. It returns 0 if the file is successfully closed and EOF (End-of-File) if an error occurs.

Here’s an example that demonstrates the usage of fclose():

#include <stdio.h>

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

    // File operations...

    int result = fclose(file);
    if (result == 0) {
        printf("File closed successfully.\n");
    } else {
        printf("Failed to close the file.\n");
    }

    return 0;
}

In this example, after opening the file with fopen(), you can perform various file operations. Once you are done with the file, fclose() is called to close the file. The return value of fclose() is checked to determine if the file was closed successfully or not.

It is good practice to always close the file when you are finished working with it to free up system resources and ensure that any pending data is written to the disk.

C fprintf() and fscanf():

The fprintf() and fscanf() functions in C are used for formatted input/output operations on files. They work in a similar way to printf() and scanf(), but instead of using the standard input/output stream (stdin/stdout), they operate on a specified file stream.

fprintf() Function:
- The fprintf() function is used to write formatted output to a file.
- Its syntax is similar to printf():

int fprintf(FILE* stream, const char* format, ...);

The stream parameter is a pointer to the FILE structure representing the file where the output will be written.
The format parameter is a string that specifies the format of the output, similar to the format string in printf().
Additional arguments can be provided based on the format string to supply values to be formatted.
The function returns the number of characters written to the file or a negative value if an error occurs.

Example usage of fprintf():

#include <stdio.h>

int main() {
    FILE* file = fopen("output.txt", "w");
    if (file == NULL) {
        printf("Failed to open the file.\n");
        return 1;
    }

    int num = 42;
    fprintf(file, "The answer is %d\n", num);

    fclose(file);
    return 0;
}

In this example, the fprintf() function is used to write the formatted output to the file “output.txt”. The %d format specifier is used to print the value of the num variable.
fscanf() Function:
- The fscanf() function is used to read formatted input from a file.
- Its syntax is similar to scanf():

int fscanf(FILE* stream, const char* format, ...);

The stream parameter is a pointer to the FILE structure representing the file from which input will be read.
The format parameter is a string that specifies the format of the input, similar to the format string in scanf().
Additional arguments can be provided based on the format string to store the read values.
The function returns the number of input items successfully matched and assigned, or EOF if an error occurs or the end-of-file is reached.

Example usage of fscanf():

#include <stdio.h>

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

    int num;
    fscanf(file, "%d", &num);
    printf("The number read from the file is: %d\n", num);

    fclose(file);
    return 0;
}

In this example, the fscanf() function is used to read an integer value from the file “input.txt”. The %d format specifier is used to specify the expected format of the input, and the read value is stored in the num variable.

Remember to always check the return values of fprintf() and fscanf() to handle any errors that may occur during the input/output operations.

C fputc() and fgetc():

The fputc() and fgetc() functions in C are used for performing character-based input/output operations on files. They allow you to read and write individual characters to and from a file.

fputc() Function:
- The fputc() function is used to write a character to a file.
- Its syntax is:

int fputc(int character, FILE* stream);

The character parameter is the character to be written to the file.
The stream parameter is a pointer to the FILE structure representing the file where the character will be written.
The function returns the character written as an unsigned char cast to an int or EOF if an error occurs.

Example usage of fputc():

#include <stdio.h>

int main() {
    FILE* file = fopen("output.txt", "w");
    if (file == NULL) {
        printf("Failed to open the file.\n");
        return 1;
    }

    int ch = 'A';
    int result = fputc(ch, file);
    if (result == EOF) {
        printf("Error writing to the file.\n");
    }

    fclose(file);
    return 0;
}

In this example, the fputc() function is used to write the character ‘A’ to the file “output.txt”. The result is checked for EOF to handle any writing errors.

2. fgetc() Function:

- The fgetc() function is used to read a character from a file.
- Its syntax is:

int fgetc(FILE* stream);

The stream parameter is a pointer to the FILE structure representing the file from which the character will be read.
The function returns the character read as an unsigned char cast to an int or EOF if an error occurs or the end-of-file is reached.

Example usage of fgetc():

#include <stdio.h>

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

    int ch = fgetc(file);
    if (ch != EOF) {
        printf("Character read from the file: %c\n", ch);
    } else {
        printf("Error reading from the file.\n");
    }

    fclose(file);
    return 0;
}

In this example, the fgetc() function is used to read a character from the file “input.txt”. The read character is checked for EOF to handle any reading errors.

It’s important to note that both fputc() and fgetc() work with individual characters, and you may need to use them within loops or in conjunction with other functions to perform operations on multiple characters or process the entire file.

C fputs() and fgets():

The fputs() and fgets() functions in C are used for performing line-based input/output operations on files. They allow you to read and write strings or lines of text to and from a file.

fputs() Function:
- The fputs() function is used to write a string to a file.
- Its syntax is:

int fputs(const char* str, FILE* stream);

The str parameter is a pointer to the null-terminated string to be written to the file.
The stream parameter is a pointer to the FILE structure representing the file where the string will be written.
The function returns a non-negative value on success or EOF if an error occurs.

Example usage of fputs():

#include <stdio.h>

int main() {
    FILE* file = fopen("output.txt", "w");
    if (file == NULL) {
        printf("Failed to open the file.\n");
        return 1;
    }

    const char* str = "Hello, World!";
    int result = fputs(str, file);
    if (result == EOF) {
        printf("Error writing to the file.\n");
    }

    fclose(file);
    return 0;
}

In this example, the fputs() function is used to write the string “Hello, World!” to the file “output.txt”. The result is checked for EOF to handle any writing errors.

2. fgets() Function:

- The fgets() function is used to read a line of text from a file.
- Its syntax is:

char* fgets(char* str, int num, FILE* stream);

The str parameter is a pointer to the character array where the read line will be stored.
The num parameter specifies the maximum number of characters to be read (including the null terminator).
The stream parameter is a pointer to the FILE structure representing the file from which the line will be read.
The function returns the str parameter on success or NULL if an error occurs or the end-of-file is reached.

Example usage of fgets():

#include <stdio.h>

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

    char buffer[100];
    char* result = fgets(buffer, sizeof(buffer), file);
    if (result != NULL) {
        printf("Line read from the file: %s", buffer);
    } else {
        printf("Error reading from the file.\n");
    }

    fclose(file);
    return 0;
}

In this example, the fgets() function is used to read a line from the file “input.txt” into the character array buffer. The read line is checked for NULL to handle any reading errors.

The fputs() and fgets() functions are commonly used for handling text files, where data is organized into lines. They can be used in loops to read or write multiple lines from or to a file.

C fseek():

The fseek() function in C is used to set the file position indicator for a given file stream. It allows you to move the position within a file, enabling random access to different parts of the file.

The syntax of the fseek() function is as follows:

int fseek(FILE* stream, long offset, int origin);

The stream parameter is a pointer to the FILE structure representing the file stream to be modified.

The offset parameter is a value of type long, which specifies the number of bytes to move the file position indicator. The actual movement depends on the value of the origin parameter.

The origin parameter specifies the reference point for the file position indicator. It can take one of the following values:

SEEK_SET: The beginning of the file is used as the reference point.
SEEK_CUR: The current position of the file position indicator is used as the reference point.
SEEK_END: The end of the file is used as the reference point.

The fseek() function returns 0 on success and a non-zero value if an error occurs.

Here’s an example that demonstrates the usage of fseek():

#include <stdio.h>

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

    // Move the file position indicator to the 10th byte from the beginning of the file
    int result = fseek(file, 10, SEEK_SET);
    if (result != 0) {
        printf("Failed to move the file position indicator.\n");
        fclose(file);
        return 1;
    }

    // Read a character from the new position
    int ch = fgetc(file);
    if (ch != EOF) {
        printf("Character at the new position: %c\n", ch);
    } else {
        printf("Error reading character.\n");
    }

    fclose(file);
    return 0;
}

In this example, the fseek() function is used to move the file position indicator to the 10th byte from the beginning of the file. Then, fgetc() is used to read a character from the new position. Note that the file should be opened in a mode that allows reading ("r") to perform the fseek() and fgetc() operations.

By using fseek(), you can navigate within a file and read or write data at specific positions, providing random access to the contents of the file.