File Handling & Command Line Arguments

What is a file?

A file is a named collection of data stored permanently on a secondary storage device (hard disk, SSD, pen drive). In C you never touch the disk directly — you work through a stream, represented by a FILE * pointer.

#include <stdio.h>

FILE *fp;                      /* a file pointer */

fp = fopen("data.txt", "w");  /* open (connect the stream) */
if (fp == NULL) return 1;   /* ALWAYS check */

fprintf(fp, "Hello file\n");  /* write */
fclose(fp);                  /* close (flush and disconnect) */

Two kinds of files in C:

Three streams are already open when your program starts:

• stdin — standard input (keyboard)
• stdout — standard output (screen)
• stderr — standard error (screen, unbuffered)

Why files?

• Persistence — data survives after the program ends and the machine restarts
• Large volumes — store far more than fits comfortably in RAM
• No re-entry — the user does not retype the same data on every run
• Sharing — one program writes, another reads; files connect programs
• Reporting — save results, logs, and invoices for later inspection
• Backup and transfer — copy, email, or archive the data
• Automated testing — feed a prepared input file instead of typing

File operations

Every file program follows the same five steps.

Opening modes

File functions in table format

(a) Open and close

(b) Character and string I/O

(c) Formatted I/O

(d) Block (binary) I/O

(e) Positioning and status

fseek origins: SEEK_SET (start), SEEK_CUR (current position), SEEK_END (end).

Command line arguments

Instead of prompting the user, a program can receive values from the command line. Give main two parameters.

int main(int argc, char *argv[]) {
    /* argc = argument count  */
    /* argv = argument vector */
}

/* Running:  ./a.out data.txt 25          */
/* argc    = 3                            */
/* argv[0] = "./a.out"   (program name)   */
/* argv[1] = "data.txt"                   */
/* argv[2] = "25"        (a STRING)       */
/* argv[3] = NULL                         */

/* Print all arguments, with validation */
#include <stdio.h>

int main(int argc, char *argv[]) {
    int i;

    if (argc < 2) {
        printf("usage: %s arg1 arg2 ...\n", argv[0]);
        return 1;
    }

    for (i = 0; i < argc; i++)
        printf("argv[%d] = %s\n", i, argv[i]);

    return 0;
}

Arguments are strings — convert them yourself:

#include <stdlib.h>

int    n = atoi(argv[1]);   /* string  → int    */
double d = atof(argv[2]);   /* string  → double */

Binary files — fwrite and fread with structures

struct Student {
    char  name[50];
    int   roll;
    float marks;
};

struct Student s = { "Asha", 101, 88.5 };

FILE *fp = fopen("rec.dat", "wb");   /* note the b */
fwrite(&s, sizeof s, 1, fp);           /* returns 1 on success */
fclose(fp);

struct Student t;
fp = fopen("rec.dat", "rb");
if (fread(&t, sizeof t, 1, fp) == 1)
    printf("%s %d %.2f\n", t.name, t.roll, t.marks);
fclose(fp);

• Both take size × count and return the count transferred
• A short return means end of file or an error — test it, do not ignore it
• Binary records are fixed size, which is what makes random access possible
• Not portable: padding and endianness differ between machines

Random access — fseek, ftell, rewind

fseek(fp, 0L, SEEK_SET);    /* first byte              */
fseek(fp, 0L, SEEK_END);    /* just past the last byte */
fseek(fp, -10L, SEEK_CUR);  /* 10 bytes back           */

/* Size of a file in bytes */
fseek(fp, 0L, SEEK_END);
long size = ftell(fp);
rewind(fp);                  /* back to the start */

/* Jump straight to record number k (0-based) */
fseek(fp, k * (long)sizeof(struct Student), SEEK_SET);
fread(&t, sizeof t, 1, fp);

The feof trap

/* WRONG — prints the last value twice */
while (!feof(fp)) {
    fscanf(fp, "%d", &n);
    printf("%d\n", n);
}

/* RIGHT — the read itself is the condition */
while (fscanf(fp, "%d", &n) == 1)
    printf("%d\n", n);

/* RIGHT — line based */
while (fgets(line, sizeof line, fp) != NULL)
    fputs(line, stdout);

/* RIGHT — character based (note: int, not char) */
int ch;
while ((ch = fgetc(fp)) != EOF)
    putchar(ch);

Error handling and buffering

#include <stdio.h>
#include <errno.h>
#include <string.h>

FILE *fp = fopen("missing.txt", "r");
if (fp == NULL) {
    perror("missing.txt");                       /* prints the OS reason  */
    fprintf(stderr, "%s\n", strerror(errno));  /* same text, as string  */
    return 1;
}

/* After a loop, tell end-of-file apart from a real error */
if (ferror(fp))
    fprintf(stderr, "read error\n");

• Buffering — output sits in memory until the buffer fills, fflush, or fclose
• stderr is unbuffered so error messages appear immediately
• fflush(stdin) is undefined behaviour — flushing is for output
• An abnormal exit without fclose can leave a file empty on disk

A real tool — copy using command line arguments

/* usage: ./copy source.txt dest.txt */
#include <stdio.h>

int main(int argc, char *argv[]) {
    FILE *in, *out;
    int ch;

    if (argc != 3) {
        fprintf(stderr, "usage: %s source dest\n", argv[0]);
        return 1;
    }

    in = fopen(argv[1], "rb");
    if (in == NULL) {
        perror(argv[1]);
        return 1;
    }

    out = fopen(argv[2], "wb");
    if (out == NULL) {
        perror(argv[2]);
        fclose(in);           /* close on the error path too */
        return 1;
    }

    while ((ch = fgetc(in)) != EOF)
        fputc(ch, out);

    fclose(in);
    fclose(out);

    printf("copied %s to %s\n", argv[1], argv[2]);
    return 0;
}

Common mistakes