C ఫైల్ హ్యాండ్లింగ్ (File Handling): టెక్స్ట్ & బైనరీ ఫైల్స్, స్ట్రీమ్స్ & పర్సిస్టెన్స్

1 ఫైల్ హ్యాండ్లింగ్ ప్రాముఖ్యత: పర్సిస్టెన్స్ & స్ట్రీమ్స్ ఆర్కిటెక్చర్

కంప్యూటర్ మెమరీ ఆర్కిటెక్చర్‌లో RAM (ప్రైమరీ మెమరీ) వేగవంతమైనది కానీ తాత్కాలికమైనది. హార్డ్ డ్రైవ్ / SSD (సెకండరీ స్టోరేజ్) నిదానమైనది కానీ శాశ్వతమైనది (Non-Volatile). C ప్రోగ్రామ్‌లు నేరుగా హార్డ్ డిస్క్‌లోని సెక్టార్లతో మాట్లాడలేవు; అవి ఆపరేటింగ్ సిస్టమ్ ద్వారా స్ట్రీమ్స్ (Streams) అనే భావనతో పనిచేస్తాయి.

స్ట్రీమ్ కమ్యూనికేషన్ ఫ్లో డయాగ్రమ్:

2 FILE* పాయింటర్ మరియు <stdio.h> బేసిక్స్

C భాషలో ఫైల్స్‌తో పనిచేసే ప్రతి ఆపరేషన్ FILE* అనే ప్రత్యేక పాయింటర్ ద్వారా జరుగుతుంది. FILE అనేది ఒక స్ట్రక్చర్, ఇది <stdio.h> లో నిర్వచించబడింది. ఇందులో:

• ఫైల్ డిస్క్రిప్టర్ నంబర్ (OS హ్యాండిల్)
• ప్రస్తుత ఫైల్ కర్సర్ లొకేషన్ (రీడ్/రైట్ పాయింటర్)
• ఇంటర్నల్ మెమరీ బఫర్ అడ్రస్
• ఎర్రర్ మరియు ఎండ్-ఆఫ్-ఫైల్ (EOF) ఫ్లాగ్స్ ఉంటాయి.

డెవలపర్‌గా మనం ఆ స్ట్రక్చర్ లోపలి వేరియబుల్స్‌ను నేరుగా తాకాల్సిన పనిలేదు. ఆపరేటింగ్ సిస్టమ్ ఆ స్ట్రక్చర్‌ను హీప్‌లో మెయింటైన్ చేస్తుంది, మనకు కేవలం దాని చిరునామాను FILE* గా ఇస్తుంది.

ఫైల్ లైఫ్‌సైకిల్ (3 గోల్డెన్ స్టెప్స్):

1. Open File: fopen() ద్వారా ఫైల్ స్ట్రీమ్‌ను తెరవడం.
2. Process File: డేటాను రాయడం (Write) లేదా చదవడం (Read).
3. Close File: fclose() ద్వారా బఫర్లను ఖాళీ చేసి ఫైల్‌ను క్లోజ్ చేయడం.

3 fopen() ఫైల్ ఓపెనింగ్ మోడ్‌లు: సమగ్ర పోలిక పట్టిక

ఫైల్‌ను తెరవడానికి fopen() ఫంక్షన్‌ను వాడతాం:

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

ఇక్కడ mode చాలా కీలకమైనది. మనం ఫైల్‌ను చదవడానికి తెరుస్తున్నామా, రాయడానికి తెరుస్తున్నామా లేదా చివరన అదనపు డేటాను జోడించడానికి తెరుస్తున్నామా అనేది ఈ మోడ్ నిర్ణయిస్తుంది:

4 ఫైల్ ఓపెనింగ్ వైఫల్యాలు & NULL చెకింగ్ (Defensive Programming)

ఫైల్ సిస్టమ్ ఆపరేషన్లలో అనేక అనిశ్చితులు ఉంటాయి. ఉదాహరణకు:

• మనం చదవాలనుకున్న ఫైల్ ఆ ఫోల్డర్‌లో లేకపోవచ్చు (File Not Found).
• ఫైల్ రీడ్-ఓన్లీగా ఉండవచ్చు లేదా మనకు పర్మిషన్లు లేకపోవచ్చు (Permission Denied).
• హార్డ్ డిస్క్ నిండిపోయి ఉండవచ్చు (Disk Full).

ఇలాంటి సందర్భాలలో fopen() విఫలమై NULL ను రిటర్న్ చేస్తుంది. ఒకవేళ మీరు NULL ని చెక్ చేయకుండా ఫైల్ ఆపరేషన్ చేస్తే ప్రోగ్రామ్ తక్షణమే క్రాష్ అవుతుంది!

perror() మరియు errno తో ఎర్రర్ హ్యాండ్లింగ్:

#include <stdio.h>
#include <stdlib.h>

int main() {
    // ఉనికిలో లేని ఫైల్‌ను చదవడానికి ప్రయత్నించడం
    FILE *fp = fopen("non_existent_file.txt", "r");

    if (fp == NULL) {
        // perror() సిస్టమ్ ఇచ్చిన ఖచ్చితమైన కారణాన్ని ప్రింట్ చేస్తుంది (ఉదా: No such file or directory)
        perror("ఫైల్ ఓపెన్ చేయడంలో లోపం");
        printf("సూచన: ఫైల్ పేరు మరియు పాత్ సరిగ్గా ఉన్నాయో లేదో సరిచూసుకోండి.\n");
        return EXIT_FAILURE;
    }

    printf("ఫైల్ విజయవంతంగా తెరవబడింది!\n");
    fclose(fp);
    return EXIT_SUCCESS;
}

5 క్యారెక్టర్ I/O: fgetc() మరియు fputc() తో ఫైల్ కాపీ ప్రోగ్రామ్

ఫైల్ నుండి ఒక్కో క్యారెక్టర్‌ను చదవడానికి మరియు రాయడానికి రెండు ప్రాథమిక ఫంక్షన్లు ఉన్నాయి:

• int fputc(int char, FILE *stream); — ఒక అక్షరాన్ని ఫైల్‌లో రాస్తుంది.
• int fgetc(FILE *stream); — ఫైల్ నుండి తదుపరి అక్షరాన్ని చదువుతుంది.

ప్రాక్టికల్ ప్రాజెక్ట్: ఫైల్ కాపీ మరియు క్యారెక్టర్ & లైన్ కౌంటర్

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 1. మొదట ఒక డెమో ఫైల్ సృష్టిద్దాం
    FILE *source = fopen("notes.txt", "w");
    if (source == NULL) {
        perror("సోర్స్ ఫైల్ క్రియేషన్ విఫలమైంది");
        return 1;
    }
    fputs("నమస్కారం! ఇది C ఫైల్ హ్యాండ్లింగ్ డెమో.\nలైన్ నంబర్ 2: C చాలా శక్తివంతమైనది.\nలైన్ నంబర్ 3: హ్యాపీ కోడింగ్!", source);
    fclose(source);

    // 2. ఇప్పుడు ఆ ఫైల్‌ను చదివి మరొక ఫైల్‌లోకి కాపీ చేయడం
    FILE *src = fopen("notes.txt", "r");
    FILE *dest = fopen("notes_backup.txt", "w");

    if (src == NULL || dest == NULL) {
        perror("ఫైల్ ఓపెన్ ఎర్రర్");
        if (src) fclose(src);
        if (dest) fclose(dest);
        return 1;
    }

    int ch;
    long char_count = 0;
    long line_count = 0;

    // ఫైల్ ముగిసే వరకు (EOF) ఒక్కో అక్షరాన్ని చదవడం
    while ((ch = fgetc(src)) != EOF) {
        fputc(ch, dest); // డెస్టినేషన్ ఫైల్‌లో రాయడం
        char_count++;
        if (ch == '\n') {
            line_count++;
        }
    }
    // చివరి లైన్ కి న్యూలైన్ లేకపోతే కౌంట్ సరిచేయడం
    if (char_count > 0) line_count++;

    fclose(src);
    fclose(dest);

    printf("✅ ఫైల్ విజయవంతంగా కాపీ చేయబడింది!\n");
    printf("మొత్తం అక్షరాలు: %ld\n", char_count);
    printf("మొత్తం లైన్లు: %ld\n", line_count);

    return 0;
}

6 లైన్ I/O: fgets() మరియు fputs() తో సురక్షితమైన స్ట్రింగ్ రీడింగ్

ఒక్కో అక్షరం కాకుండా మొత్తం ఒక వాక్యాన్ని లేదా లైన్‌ను చదవడానికి మరియు రాయడానికి స్ట్రింగ్ ఫంక్షన్లు వాడతాం:

• int fputs(const char *str, FILE *stream); — స్ట్రింగ్‌ను ఫైల్‌లో రాస్తుంది.
• char* fgets(char *str, int num, FILE *stream); — ఫైల్ నుండి గరిష్టంగా num - 1 అక్షరాల వరకు ఒక లైన్‌ను చదువుతుంది.

fgets() తో టెక్స్ట్ ఫైల్‌ను లైన్ బై లైన్ రీడ్ చేసే కోడ్:

#include <stdio.h>
#include <stdlib.h>

#define BUFFER_SIZE 256

int main() {
    FILE *fp = fopen("config.txt", "w");
    if (!fp) return 1;

    fputs("SERVER_PORT=8080\n", fp);
    fputs("DATABASE_URL=localhost:5432\n", fp);
    fputs("DEBUG_MODE=true\n", fp);
    fclose(fp);

    // చదవడానికి తెరవడం
    fp = fopen("config.txt", "r");
    if (!fp) return 1;

    char line[BUFFER_SIZE];
    int line_num = 1;

    printf("--- కాన్ఫిగరేషన్ ఫైల్ కంటెంట్ ---\n");
    // fgets ఫైల్ చివరకు రాగానే NULL రిటర్న్ చేస్తుంది
    while (fgets(line, sizeof(line), fp) != NULL) {
        printf("[%02d]: %s", line_num++, line);
    }

    fclose(fp);
    return 0;
}

7 ఫార్మాటెడ్ I/O: fprintf() మరియు fscanf()

మనకు సాధారణ printf() మరియు scanf() ఎలాగో, ఫైల్స్‌తో మాట్లాడటానికి fprintf() మరియు fscanf() అలాగే పనిచేస్తాయి. కేవలం మొదటి ఆర్గ్యుమెంట్‌గా FILE* పాయింటర్‌ను ఇస్తే సరిపోతుంది!

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

fprintf మరియు fscanf తో స్టూడెంట్ గ్రేడ్ షీట్ జనరేషన్:

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 1. డేటాను ఫార్మాట్ చేసి రాయడం (fprintf)
    FILE *fp = fopen("marks.txt", "w");
    if (!fp) { perror("ఫైల్ ఓపెన్ విఫలం"); return 1; }

    fprintf(fp, "%d %s %.2f\n", 101, "కార్తీక్", 88.5);
    fprintf(fp, "%d %s %.2f\n", 102, "లావణ్య", 94.0);
    fprintf(fp, "%d %s %.2f\n", 103, "ప్రదీప్", 76.5);
    fclose(fp);

    // 2. ఫైల్ నుండి ఫార్మాటెడ్ డేటాను చదవడం (fscanf)
    fp = fopen("marks.txt", "r");
    if (!fp) { perror("ఫైల్ రీడ్ విఫలం"); return 1; }

    int roll;
    char name[50];
    float marks;

    printf("%-8s %-15s %-8s\n", "రోల్ నం", "పేరు", "మార్కులు");
    printf("------------------------------------\n");

    // fscanf సక్సెస్ ఫుల్‌గా రీడ్ చేసిన వేరియబుల్స్ సంఖ్యను రిటర్న్ చేస్తుంది (ఇక్కడ 3)
    while (fscanf(fp, "%d %49s %f", &roll, name, &marks) == 3) {
        printf("%-8d %-15s %-8.2f\n", roll, name, marks);
    }

    fclose(fp);
    return 0;
}

8 టెక్స్ట్ ఫైల్స్ vs బైనరీ ఫైల్స్: లోతైన ఆర్కిటెక్చర్ తేడాలు

కంప్యూటర్‌లో ఫైల్స్ ప్రధానంగా రెండు వర్గాలుగా ఉంటాయి: టెక్స్ట్ ఫైల్స్ (Text Files) మరియు బైనరీ ఫైల్స్ (Binary Files). వీటి మధ్య వ్యత్యాసం అర్థం చేసుకోవడం ద్వారా సిస్టమ్ లెవల్ ప్రోగ్రామింగ్‌లో తప్పులు జరగకుండా నివారించవచ్చు:

9 బైనరీ I/O: fwrite() మరియు fread() తో స్ట్రక్చర్స్ నిల్వ చేయడం

స్ట్రక్చర్లు, అర్రేలు లేదా భారీ డేటాను టెక్స్ట్‌గా మార్చకుండా నేరుగా మెమరీ బైట్లుగా ఫైల్‌లో దాచడానికి fwrite() మరియు fread() ఫంక్షన్లను ఉపయోగిస్తాం.

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

ఇవి నాలుగు పారామీటర్లను తీసుకుంటాయి:

1. ptr: రాయాల్సిన లేదా చదవాల్సిన వేరియబుల్ మెమరీ అడ్రస్.
2. size: ఒక్కో ఐటమ్ సైజు (ఉదా: sizeof(Employee)).
3. count: మొత్తం ఎన్ని ఐటమ్స్ ప్రాసెస్ చేయాలి.
4. stream: ఓపెన్ చేయబడిన బైనరీ ఫైల్ పాయింటర్.

పూర్తి స్ట్రక్చర్‌ను ఒకే ఒక్క కాల్‌తో బైనరీ ఫైల్‌లో సేవ్ చేయడం:

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

typedef struct {
    int id;
    char name[30];
    double salary;
} Employee;

int main() {
    Employee emp_out[2] = {
        {101, "రాజేష్ వర్మ", 75000.50},
        {102, "సునీత రావు", 88000.00}
    };

    // 1. బైనరీ ఫైల్‌లో రాయడం ("wb" - Write Binary)
    FILE *fp = fopen("employees.bin", "wb");
    if (!fp) { perror("ఫైల్ ఓపెన్ ఫెయిల్"); return 1; }

    // ఒకే ఒక్క CPU ఇన్‌స్ట్రక్షన్‌తో మొత్తం 2 స్ట్రక్చర్ల డేటాను డిస్క్‌పై రాయడం
    size_t written = fwrite(emp_out, sizeof(Employee), 2, fp);
    fclose(fp);
    printf("✅ %zu ఉద్యోగుల రికార్డులు బైనరీ ఫైల్‌లో భద్రపరచబడ్డాయి.\n", written);

    // 2. బైనరీ ఫైల్ నుండి చదవడం ("rb" - Read Binary)
    fp = fopen("employees.bin", "rb");
    if (!fp) { perror("రీడ్ ఫెయిల్"); return 1; }

    Employee emp_in;
    printf("\n--- బైనరీ ఫైల్ నుండి చదివిన ఉద్యోగుల వివరాలు ---\n");
    while (fread(&emp_in, sizeof(Employee), 1, fp) == 1) {
        printf("ID: %d | పేరు: %-15s | జీతం: ₹%.2f\n", emp_in.id, emp_in.name, emp_in.salary);
    }

    fclose(fp);
    return 0;
}

10 రాండమ్ యాక్సెస్: fseek(), ftell(), rewind() తో ఫైల్ కర్సర్ నావిగేషన్

సాధారణంగా ఫైల్ ఆపరేషన్లు మొదటి అక్షరం నుండి వరుసగా (Sequential Access) జరుగుతాయి. కానీ 10 లక్షల రికార్డులు ఉన్న భారీ ఫైల్‌లో నేరుగా 500వ రికార్డును చదవాలంటే లేదా మార్చాలంటే మొత్తం ఫైల్ చదవడం సమయం వృధా! దీనిని నివారించడానికి C మనకు రాండమ్ యాక్సెస్ (Random Access) ఫంక్షన్లను అందిస్తుంది:

• int fseek(FILE *stream, long offset, int origin); — కర్సర్‌ను మనకు నచ్చిన స్థానానికి తరలిస్తుంది.
• long ftell(FILE *stream); — ఫైల్ ప్రారంభం నుండి కర్సర్ ప్రస్తుతం ఎన్నో బైట్ వద్ద ఉందో తెలుపుతుంది.
• void rewind(FILE *stream); — కర్సర్‌ను తిరిగి ఫైల్ మొదటికి (0 బైట్) తెస్తుంది.

fseek() లో 3 మూల స్థానాలు (Origins):

11 బఫరింగ్, fflush() మరియు ఫైల్ ఎర్రర్ హ్యాండ్లింగ్ (feof & ferror)

ప్రతిసారి మనం ఒక అక్షరాన్ని రాసినప్పుడు ఆపరేటింగ్ సిస్టమ్ హార్డ్ డిస్క్‌ను తిప్పదు. వేగం కోసం C లైబ్రరీ ముందుగా డేటాను RAM లోని ఒక ఇంటర్నల్ బఫర్‌లో దాచిపెడుతుంది. బఫర్ నిండినప్పుడు మాత్రమే డిస్క్‌పై రాస్తుంది.

కానీ ఏదైనా కారణం చేత కంప్యూటర్ పవర్ పోతే బఫర్‌లోని డేటా డిస్క్‌కు చేరకుండానే నశించిపోతుంది. అందువల్ల అత్యవసర డేటాను తక్షణమే డిస్క్‌కు పంపించడానికి fflush(fp); ను పిలుస్తాం.

12 రియల్-వరల్డ్ ప్రాజెక్ట్: పర్సిస్టెంట్ కాంటాక్ట్ డైరెక్టరీ / ఫోన్‌బుక్ సిస్టమ్

ఇప్పుడు మనం నేర్చుకున్న బైనరీ ఫైల్ హ్యాండ్లింగ్, స్ట్రక్చర్స్ మరియు ఫైల్ కర్సర్ కాన్సెప్ట్‌లతో ఒక పూర్తి స్థాయి పర్సిస్టెంట్ కాంటాక్ట్స్ మేనేజర్ (Persistent CLI Phonebook) ను నిర్మిద్దాం. ఈ ప్రోగ్రామ్‌ను క్లోజ్ చేసి మళ్లీ ఓపెన్ చేసినా కాంటాక్ట్స్ సురక్షితంగా ఉంటాయి!

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

#define FILENAME "contacts.dat"

typedef struct {
    int id;
    char name[40];
    char phone[15];
    char email[40];
} Contact;

// 1. కొత్త కాంటాక్ట్‌ను ఫైల్ చివరన చేర్చడం ("ab" mode)
void add_contact(int id, const char *name, const char *phone, const char *email) {
    FILE *fp = fopen(FILENAME, "ab");
    if (!fp) {
        perror("కాంటాక్ట్ ఫైల్ తెరవలేకపోయాం");
        return;
    }

    Contact c;
    c.id = id;
    strncpy(c.name, name, sizeof(c.name) - 1);
    c.name[sizeof(c.name) - 1] = '\0';
    strncpy(c.phone, phone, sizeof(c.phone) - 1);
    c.phone[sizeof(c.phone) - 1] = '\0';
    strncpy(c.email, email, sizeof(c.email) - 1);
    c.email[sizeof(c.email) - 1] = '\0';

    fwrite(&c, sizeof(Contact), 1, fp);
    fclose(fp);
    printf("✅ కాంటాక్ట్ సేవ్ అయింది: %s (%s)\n", name, phone);
}

// 2. అన్ని కాంటాక్ట్‌లను ఫైల్ నుండి చదివి చూపించడం ("rb" mode)
void list_all_contacts() {
    FILE *fp = fopen(FILENAME, "rb");
    if (!fp) {
        printf("⚠️ ఇంకా ఎలాంటి కాంటాక్ట్స్ సేవ్ చేయబడలేదు.\n");
        return;
    }

    Contact c;
    printf("\n==================== ఫోన్‌బుక్ డైరెక్టరీ ====================\n");
    printf("%-5s %-20s %-15s %-25s\n", "ID", "పేరు", "ఫోన్ నంబర్", "ఈమెయిల్");
    printf("------------------------------------------------------------\n");

    int count = 0;
    while (fread(&c, sizeof(Contact), 1, fp) == 1) {
        printf("%-5d %-20s %-15s %-25s\n", c.id, c.name, c.phone, c.email);
        count++;
    }
    printf("============================================================\n");
    printf("మొత్తం కాంటాక్ట్స్: %d\n\n", count);
    fclose(fp);
}

// 3. పేరు ఆధారంగా వెతకడం
void search_contact(const char *search_name) {
    FILE *fp = fopen(FILENAME, "rb");
    if (!fp) {
        printf("ఫైల్ అందుబాటులో లేదు.\n");
        return;
    }

    Contact c;
    int found = 0;
    while (fread(&c, sizeof(Contact), 1, fp) == 1) {
        if (strstr(c.name, search_name) != NULL) {
            printf("🔍 దొరికింది! -> ID: %d | పేరు: %s | ఫోన్: %s | ఈమెయిల్: %s\n", 
                   c.id, c.name, c.phone, c.email);
            found = 1;
        }
    }

    if (!found) {
        printf("❌ '%s' పేరుతో ఎలాంటి కాంటాక్ట్ దొరకలేదు.\n", search_name);
    }
    fclose(fp);
}

int main() {
    printf("=== పర్సిస్టెంట్ ఫోన్‌బుక్ సిస్టమ్ ప్రారంభం ===\n");

    // టెస్ట్ కోసం కొన్ని కాంటాక్ట్‌లను జోడించడం
    add_contact(1, "శ్రీధర్ పట్నాయక్", "9848022338", "sridhar@gmail.com");
    add_contact(2, "భార్గవి కొమర్రాజు", "9988776655", "bhargavi@yahoo.com");
    add_contact(3, "కిరణ్ కుమార్", "9123456789", "kiran@outlook.com");

    // మొత్తం లిస్ట్‌ను డిస్‌ప్లే చేయడం
    list_all_contacts();

    // సెర్చ్ టెస్టింగ్
    printf("వెతుకుతున్నాం 'భార్గవి'...\n");
    search_contact("భార్గవి");

    return 0;
}

13 సారాంశం, ఇంటర్వ్యూ ప్రశ్నలు & సెల్ఫ్-అసెస్మెంట్ క్విజ్

కీలక సారాంశం (Key Takeaways):

• Data Persistence: RAM తాత్కాలికం; ఫైల్స్ ద్వారా డేటా డిస్క్‌లో శాశ్వతంగా భద్రపరచబడుతుంది.
• FILE* Pointer: ఫైల్ స్ట్రీమ్, బఫర్ మరియు కర్సర్ లొకేషన్‌ను నిర్వహించే కీ హ్యాండిల్.
• Defensive fopen(): ఎల్లప్పుడూ if (fp == NULL) చెక్ చేయాలి మరియు perror() వాడాలి.
• Character & String I/O: fgetc/fputc ఒక్కో అక్షరానికి; fgets/fputs భద్రమైన లైన్ రీడింగ్‌కు.
• Formatted vs Binary: fprintf/fscanf టెక్స్ట్ ఫైల్స్‌కు; fwrite/fread హై-స్పీడ్ బైనరీ డేటాకు.
• Random Access: fseek() మరియు ftell() ద్వారా నేరుగా కావలసిన బైట్‌కు జంప్ చేయవచ్చు.
• fclose(): బఫర్లను డిస్క్‌పై రాసి OS హ్యాండిల్‌ను విడుదల చేయడానికి తప్పనిసరి.

టాప్ 5 C ఫైల్ హ్యాండ్లింగ్ ఇంటర్వ్యూ ప్రశ్నలు:

1. Q1: fclose() చేయడం మర్చిపోతే ఏమవుతుంది?
   జవాబు: బఫర్‌లో ఉన్న డేటా డిస్క్‌పై రాయబడకపోవచ్చు (Data Loss). అలాగే OS ఫైల్ హ్యాండిల్స్ పరిమిత సంఖ్యలో ఉంటాయి కాబట్టి ఇతర ప్రోగ్రామ్‌లు ఆ ఫైల్‌ను లాక్ చేయడంలో విఫలమవ్వచ్చు.
2. Q2: Windows లో టెక్స్ట్ మోడ్ ("r") మరియు బైనరీ మోడ్ ("rb") మధ్య తేడా ఏమిటి?
   జవాబు: విండోస్ టెక్స్ట్ మోడ్‌లో రీడ్ చేసేటప్పుడు \r\n ఆటోమేటిక్‌గా ఒకే \n గా మారుతుంది. బైనరీ మోడ్‌లో ఎలాంటి మార్పు లేకుండా ప్రతి బైట్ ఖచ్చితంగా యథాతథంగా చదవబడుతుంది.
3. Q3: remove() మరియు rename() ఫంక్షన్లు ఎలా పనిచేస్తాయి?
   జవాబు: <stdio.h> లో ఉండే remove("file.txt") ఫైల్‌ను డిలీట్ చేస్తుంది; rename("old.txt", "new.txt") ఫైల్ పేరును లేదా పాత్‌ను మారుస్తుంది.
4. Q4: rewind(fp) ఫంక్షన్ దేనికి సమానం?
   జవాబు: (void)fseek(fp, 0L, SEEK_SET); తో పాటు ఫైల్ ఎర్రర్ ఇండికేటర్‌ను క్లియర్ చేస్తుంది.
5. Q5: fgets() మరియు fscanf("%s") మధ్య భద్రతా వ్యత్యాసం ఏమిటి?
   జవాబు: fscanf("%s", str) స్పేస్ రాగానే ఆగిపోతుంది మరియు బౌండరీ చెక్ లేకపోతే బఫర్ ఓవర్‌ఫ్లో చేస్తుంది. fgets(str, size, fp) ఖచ్చితంగా size పరిమితికి లోబడి మాత్రమే చదువుతుంది మరియు స్పేస్‌లతో కూడిన మొత్తం వాక్యాన్ని రీడ్ చేస్తుంది.

ఇంటరాక్టివ్ సెల్ఫ్-అసెస్మెంట్ క్విజ్ (Self-Assessment Quiz):