Day_10 C-Programming
(RECAP OF PREVIOUS DAY)
File Types, File operations, File pointer, File opening modes, File handling functions,
Command Line Arguments, File handling through command line argument, Record I/O in
files, Preprocessor directives: Macros and File inclusion
File Types in C
Files in C are used for permanent storage of data. C supports two types of files:
1. Text Files:
○ Contain data in human-readable format.
○ Example: .txt, .csv
2. Binary Files:
○ Contain data in machine-readable format (0s and 1s).
○ Example: .bin, .dat
File Operations in C
C provides a set of operations to handle files:
1. Create a file: Create a new file for storing data.
2. Open a file: Open an existing file for reading or writing.
3. Read from a file: Retrieve data from the file.
4. Write to a file: Write data to the file.
5. Close a file: Close the file to free resources.
File Pointer
● A file pointer is a pointer to a FILE structure, used to control file operations.
Syntax:
FILE *fp;
fp = fopen("example.txt", "r");
if (fp == NULL) {
printf("File could not be opened\n");
}
fclose(fp);
File Opening Modes
C provides multiple modes for opening files:
Mode Description
"r" Open for reading. File must exist.
"w" Open for writing. Creates/truncates.
"a" Open for appending. Creates if absent.
"r+" Open for reading and writing.
"w+" Open for reading and writing.
"a+" Open for reading and appending.
"rb" Open for reading in binary mode.
"wb" Open for writing in binary mode.
File Handling Functions
1. Opening a file:
○ FILE *fopen(const char *filename, const char *mode);
Example:
FILE *fp = fopen("data.txt", "r");
2. Closing a file:
○ int fclose(FILE *fp);
Example:
fclose(fp);
3. Reading from a file:
○ fgetc(): Read a single character.
○ fgets(): Read a string.
○ fread(): Read binary data.
Example:
char ch = fgetc(fp);
4. Writing to a file:
○ fputc(): Write a single character.
○ fputs(): Write a string.
○ fwrite(): Write binary data.
Example:
fputc('A', fp);
5. Positioning Functions:
○ fseek(): Move the file pointer to the desired location.
○ ftell(): tells the current position of the file pointer.
○ rewind(): Set the file pointer to the start.
We will see examples later in this session
Some File Programs
Example:
Program that writes content into a file and then reads it back to display on the screen
#include <stdio.h>
int main() {
FILE *file;
char content[] = "This is a sample text written into the file.\nThis is the second line.\n";
// Open the file for writing
file = fopen("sample.txt", "w");
if (file == NULL) {
printf("Error opening the file for writing.\n");
return 1;
}
// Write content into the file
fprintf(file, "%s", content);
// Close the file after writing
fclose(file);
printf("Content has been written to the file.\n");
// Open the file for reading
file = fopen("sample.txt", "r");
if (file == NULL) {
printf("Error opening the file for reading.\n");
return 1;
}
// Display the content of the file
printf("\nReading the content from the file:\n");
char ch;
while ((ch = fgetc(file)) != EOF) {
putchar(ch); // Print each character to the screen
}
// Close the file after reading
fclose(file);
return 0;
}
Example:
Write a program that takes 30 numbers as input, writes them into a file, then separates even
and odd numbers into two different files named EVEN.txt and ODD.txt
#include <stdio.h>
int main() {
FILE *inputFile, *evenFile, *oddFile;
int numbers[30];
int i;
// Open the input file for writing
inputFile = fopen("numbers.txt", "w");
if (inputFile == NULL) {
printf("Error opening numbers.txt file.\n");
return 1;
}
// Taking 30 numbers as input from the user
printf("Enter 30 numbers:\n");
for (i = 0; i < 30; i++) {
scanf("%d", &numbers[i]);
fprintf(inputFile, "%d\n", numbers[i]); // Write each number to the file
}
// Close the input file after writing
fclose(inputFile);
// Open the EVEN and ODD files for writing
evenFile = fopen("EVEN.txt", "w");
oddFile = fopen("ODD.txt", "w");
if (evenFile == NULL || oddFile == NULL) {
printf("Error opening EVEN.txt or ODD.txt file.\n");
return 1;
}
// Separate the even and odd numbers and write them to respective files
for (i = 0; i < 30; i++) {
if (numbers[i] % 2 == 0) {
fprintf(evenFile, "%d\n", numbers[i]);
} else {
fprintf(oddFile, "%d\n", numbers[i]);
}
}
// Close the EVEN and ODD files after writing
fclose(evenFile);
fclose(oddFile);
printf("The numbers have been separated into EVEN.txt and ODD.txt files.\n");
return 0;
}
Example:
example of fseek, ftell, and rewind
#include <stdio.h>
int main() {
// Open a file for writing
FILE *file = fopen("example.txt", "w");
if (file == NULL) {
printf("Error opening file\n");
return 1;
}
// Write some data to the file
fprintf(file, "Hello, World!\nThis is an example of fseek, ftell, and rewind.");
// Move the file pointer 6 bytes from the beginning
fseek(file, 6, SEEK_SET);
printf("File pointer moved to position: %ld\n", ftell(file)); // Prints 6
// Move the file pointer 5 bytes ahead from the current position
fseek(file, 5, SEEK_CUR);
printf("File pointer moved to position: %ld\n", ftell(file)); // Prints 11
// Move the file pointer 5 bytes from the end
fseek(file, -5, SEEK_END);
printf("File pointer moved to position: %ld\n", ftell(file)); // Prints position 47 (based on file
size)
// Rewind the file pointer to the start
rewind(file);
printf("File pointer after rewind: %ld\n", ftell(file)); // Prints 0
// Close the file
fclose(file);
return 0;
}
Command Line Arguments
● Command-line arguments allow passing inputs to the program at runtime.
Syntax:
int main(int argc, char *argv[])
○ argc: Number of arguments.
○ argv: Array of arguments.
Example:
#include <stdio.h>
int main(int argc, char *argv[]) {
printf("Program name: %s\n", argv[0]);
if (argc > 1) {
printf("Argument: %s\n", argv[1]);
}
return 0;
}
To Run it from command line
● Lets name it as MyProg.c
● Compile it from command line
● Run it without argument” MyProg.c
○ Output: Program name:MyProg.c
● Run it with argument: MyProg.c Hello
○ Output: Program name:MyProg.c
Argument: Hello
File Handling Through Command Line Arguments
Example program to copy the contents of one file to another:
#include <stdio.h>
int main(int argc, char *argv[]) {
if (argc != 3) {
printf("Usage: %s source_file target_file\n", argv[0]);
return 1;
}
FILE *src = fopen(argv[1], "r");
FILE *dest = fopen(argv[2], "w");
if (src == NULL || dest == NULL) {
printf("Error opening file.\n");
return 1;
}
char ch;
while ((ch = fgetc(src)) != EOF) {
fputc(ch, dest);
}
fclose(src);
fclose(dest);
printf("File copied successfully.\n");
return 0;
}
Record I/O in Files
● Used to store and retrieve structured data (e.g., records of employees).
Example:
#include <stdio.h>
struct Employee {
int id;
char name[50];
float salary;
};
int main() {
struct Employee e = {1, "Alice", 50000.0};
FILE *fp = fopen("employee.dat", "wb");
fwrite(&e, sizeof(struct Employee), 1, fp);
fclose(fp);
struct Employee e_read;
fp = fopen("employee.dat", "rb");
fread(&e_read, sizeof(struct Employee), 1, fp);
fclose(fp);
printf("ID: %d, Name: %s, Salary: %.2f\n", e_read.id, e_read.name, e_read.salary);
return 0;
}
Preprocessor Directives
a. Macros:
● Macro is a piece of code in a program that is replaced by the value of the macro.
● Macros are constants or functions defined using the #define directive.
Example:
#define PI 3.14159
#define SQUARE(x) ((x) * (x))
int main() {
printf("PI: %.2f\n", PI);
printf("Square of 5: %d\n", SQUARE(5));
return 0;
}
Program: Calculate Area of a Circle Using a Macro
#include <stdio.h>
#define PI 3.14159
#define AREA_OF_CIRCLE(radius) (PI * (radius) * (radius))
int main() {
float radius;
printf("Enter the radius of the circle: ");
scanf("%f", &radius);
float area = AREA_OF_CIRCLE(radius);
printf("The area of the circle with radius %.2f is: %.2f\n", radius, area);
return 0;
}
b. File Inclusion:
● Used to include header files or other files into the program.
Two main types of include file directives in C:
1. #include <filename.h>:
The use of this syntax is to include system header file in C program. It tells the compiler to look
for or find the file in the standard system directory.
2. #include “filename”:
This syntax is used to add a header file. It tells the compiler to first look for the file in the current
directory and then look in the system directory.
#include <stdio.h>
#include "myheader.h" // User-defined header file
___________________
Programs to practice(HW)
1. File Types and File Operations
● Program 1: Create a text file and write data into it using fwrite().
● Program 2: Read data from a file using fread() and display it on the screen.
● Program 3: Append data to an existing file without overwriting using fopen() in append
mode.
2. File Pointer and File Operations
● Program 4: Move the file pointer using fseek(), ftell(), and rewind(), and
display the current file pointer position at various stages.
● Program 5: Implement a program that uses fseek() to search for a specific word or
pattern in a file.
● Program 6: Read and display file content in reverse order using fseek().
3. File Opening Modes
● Program 7: Open a file in different modes ("r", "w", "a", "r+", "w+", "a+") and
handle errors for each mode.
● Program 8: Create a program that handles errors gracefully when trying to open a file
that doesn’t exist in "r" mode, or when trying to write in "r" mode.
4. File Handling Functions
● Program 9: Use fopen(), fclose(), fgetc(), and fputc() to read and write one
character at a time in a file.
● Program 10: Implement a program that reads from a file line-by-line using fgets() and
writes the content to another file.
● Program 11: Write a program that reads and writes a structured record (e.g., struct
type) to/from a binary file using fwrite() and fread().
5. Command Line Arguments
● Program 12: Write a program that takes two numbers from the command line, adds
them, and displays the sum.
● Program 13: Create a program that takes a list of strings as command-line arguments
and prints each string.
● Program 14: Implement a program that takes a file name as a command-line argument,
reads the content of that file, and prints it.
6. File Handling through Command Line Arguments
● Program 15: Write a program that accepts a file name as a command-line argument,
opens the file, reads the content, and displays it.
● Program 16: Create a program that accepts file names from the command line, and
copies content from the source file to the destination file.
● Program 17: Implement a program that accepts a file name and a word from the
command line and counts how many times the word appears in the file.
7. Record I/O in Files
● Program 18: Implement a program to write student records (name, roll number, marks)
into a file using struct and binary file operations (fwrite(), fread()).
● Program 19: Write a program to read and display student records from a file, and
update a student record (e.g., modify marks) in the file.
● Program 20: Create a program that writes multiple records (students) into a file, then
reads the file and displays the records in tabular format.
8. Preprocessor Directives: Macros and File Inclusion
● Program 21: Implement a program that uses macros to find the maximum of two
numbers.
● Program 22: Create a program with a header file (.h) that contains function prototypes
for file operations, and implement the functions in a separate .c file.
● Program 23: Write a program that includes an external header file with preprocessor
directives to define constants and use them in the program.
● Program 24: Implement a program that defines a macro for a factorial and uses it to
compute the factorial of a number.
9. (Mixed Topics)
● Program 25: Write a program that takes a list of students' names and grades from the
user, writes them to a file, and later reads and sorts the data in ascending order based
on grades.
● Program 26: Create a program to count the number of lines, words, and characters in a
file using fgetc() or fgets().
● Program 27: Write a program that reads integers from a file, computes their average,
and writes the result to a new file.
