File Handling &
Preprocessor Directives

FILE *fp;     /* fp is a "handle" to an open file */

FILE *fp = fopen("data.txt", "r");   /* filename, mode */

if(fp == NULL)
{
    printf("Unable to open file\n");
    return 1;          /* never assume the file opened successfully */
}

FILE *fp = fopen("data.txt", "r");
/* ... use fp ... */
fclose(fp);

#include <stdio.h>

int main()
{
    /* Writing */
    FILE *fp = fopen("marks.txt", "w");
    if(fp == NULL) return 1;

    fprintf(fp, "Alice %d\n", 95);
    fclose(fp);

    /* Reading it back */
    fp = fopen("marks.txt", "r");
    if(fp == NULL) return 1;

    char name[30];
    int  marks;
    fscanf(fp, "%s %d", name, &marks);
    printf("%s scored %d\n", name, marks);   /* Alice scored 95 */

    fclose(fp);
    return 0;
}

int fgetc(FILE *fp);     /* returns the character read, or EOF */

FILE *fp = fopen("data.txt", "r");
int ch;

while((ch = fgetc(fp)) != EOF)
{
    printf("%c", ch);     /* prints every character until EOF */
}
fclose(fp);

int fputc(int ch, FILE *fp);

FILE *fp = fopen("letters.txt", "w");
fputc('A', fp);
fputc('B', fp);
fputc('C', fp);
fclose(fp);
/* letters.txt now contains: ABC */

char *fgets(char *str, int size, FILE *fp);
int   fputs(const char *str, FILE *fp);

/* Reading one line, safely bounded by sizeof(line) */
char line[100];
FILE *fp = fopen("data.txt", "r");
fgets(line, sizeof(line), fp);
printf("%s", line);
fclose(fp);

/* Writing a string */
fp = fopen("output.txt", "w");
fputs("Embedded Systems", fp);
fclose(fp);

size_t fwrite(const void *ptr, size_t size, size_t count, FILE *fp);
size_t fread (      void *ptr, size_t size, size_t count, FILE *fp);

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

/* Writing */
struct Student s = {101, "Alice", 92.5};
FILE *fp = fopen("student.dat", "wb");
fwrite(&s, sizeof(struct Student), 1, fp);   /* 1 record */
fclose(fp);

/* Reading it back */
struct Student loaded;
fp = fopen("student.dat", "rb");
fread(&loaded, sizeof(struct Student), 1, fp);
fclose(fp);
/* loaded now contains exactly what was saved */

long ftell(FILE *fp);                     /* current position    */
void rewind(FILE *fp);                    /* jump to position 0  */
int  fseek(FILE *fp, long offset, int origin);

/* Example: file contains "ABCDE" */
fgetc(fp); fgetc(fp); fgetc(fp);   /* read "ABC" */
printf("%ld\n", ftell(fp));         /* 3 — position after 3 reads */

rewind(fp);                          /* back to the very start */

fseek(fp, 5, SEEK_SET);             /* jump to byte 5 from start */
fseek(fp, -2, SEEK_END);            /* 2 bytes before the end    */
fseek(fp, 3, SEEK_CUR);             /* 3 bytes forward from here */

int ch;
while((ch = fgetc(fp)) != EOF)
{
    putchar(ch);
}

/* math_utils.h — declarations only */
int add(int a, int b);
int subtract(int a, int b);

/* math_utils.c — implementation */
#include "math_utils.h"
int add(int a, int b)      { return a + b; }
int subtract(int a, int b) { return a - b; }

/* main.c — usage */
#include <stdio.h>
#include "math_utils.h"

int main()
{
    printf("%d\n", add(5, 3));   /* 8 */
    return 0;
}

#define PI 3.14159
#define MAX 100

float area = PI * r * r;
int   arr[MAX];

/* The compiler never sees PI or MAX — after preprocessing it sees: */
float area = 3.14159 * r * r;
int   arr[100];

#define SQUARE(x) ((x) * (x))
#define MAX(a,b)  ((a) > (b) ? (a) : (b))

int a = SQUARE(5);          /* expands to: ((5) * (5))  → 25 */
int m = MAX(10, 20);        /* expands to: ((10)>(20)?(10):(20)) → 20 */

#define MAX(a,b) ((a) > (b) ? (a) : (b))

int x = 5;
int y = MAX(x++, 10);
/* x++ may be expanded (and evaluated) TWICE in the comparison —
   the macro's textual nature means side-effecting arguments
   behave unpredictably depending on which branch is taken */

/* #if — evaluate a constant expression */
#define VERSION 2
#if VERSION == 2
    printf("Version 2");
#endif

/* #ifdef — compile only if macro IS defined */
#define DEBUG
#ifdef DEBUG
    printf("Debug Enabled");
#endif

/* #ifndef — compile only if macro is NOT defined */
#ifndef DEBUG
    printf("Release Mode");
#endif

/* #else and #elif — like else / else-if, but for the preprocessor */
#if VERSION == 1
    printf("V1");
#elif VERSION == 2
    printf("V2");           /* this branch compiles */
#else
    printf("Unknown");
#endif

/* #undef — remove a macro definition */
#define SIZE 100
#undef SIZE
/* SIZE is now undefined again */

#ifndef STUDENT_H      /* has STUDENT_H been defined yet? */
#define STUDENT_H       /* if not, define it now           */

struct Student
{
    int roll;
};

#endif                  /* end of the guarded block         */

Project/
├── main.c
├── uart.c
├── uart.h
├── gpio.c
├── gpio.h
├── adc.c
├── adc.h
└── Makefile