ഫയൽ output ട്ട്പുട്ടിലെ അപ്രതീക്ഷിത ചൈനീസ് പ്രതീകങ്ങൾ: സി ഫയൽ കൈകാര്യം ചെയ്യൽ ഡീബഗ്ഗിംഗ് ചെയ്യുന്നു

നിങ്ങളുടെ സി പ്രോഗ്രാം വാചകത്തിന് പകരം ഗിബ്ബരിഷുമായി എഴുതുമ്പോൾ

നിങ്ങൾ സി പഠിക്കാൻ തുടങ്ങി, ഫയൽ കൈകാര്യം ചെയ്യൽ പരീക്ഷിക്കാൻ ആവേശത്തിലാണ്. ഒരു ടെക്സ്റ്റ് ഫയലിലേക്ക് "ഹലോ ലോകം" സംരക്ഷിക്കുന്നതിന് നിങ്ങൾ ഒരു ലളിതമായ പ്രോഗ്രാം എഴുതുന്നു, പക്ഷേ നിങ്ങൾ ഫയൽ തുറക്കുമ്പോൾ, വാചകം വിചിത്രമായ ചൈനീസ് പ്രതീകങ്ങൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. 🤯 എന്താണ് തെറ്റ് സംഭവിച്ചത്?

ഈ പ്രശ്നം തികച്ചും നിരാശാജനകമാണ്, പ്രത്യേകിച്ച് തുടക്കക്കാർക്ക്. തെറ്റായ ഫയൽ കൈകാര്യം ചെയ്യൽ, ദുരുപയോഗം ചെയ്യുന്ന പ്രവർത്തനങ്ങൾ അല്ലെങ്കിൽ എൻകോഡിംഗ് പ്രശ്നങ്ങൾ എന്നിവ കാരണം ഇത് പലപ്പോഴും സംഭവിക്കുന്നു. നിങ്ങളുടെ പ്രോഗ്രാം വായിക്കാനോ എഴുതാനോ ഇല്ലെങ്കിൽ, അത് അപ്രതീക്ഷിതമായി ഡാറ്റ വ്യാഖ്യാനിച്ചേക്കാം.

ഒരു കുറിപ്പ് ഇംഗ്ലീഷിൽ എഴുതുന്നത് സങ്കൽപ്പിക്കുക, പക്ഷേ നിങ്ങൾ അത് ഒരു സുഹൃത്തിന് കൈമാറുമ്പോൾ, അവ തികച്ചും വ്യത്യസ്തമായ ഭാഷയിൽ വായിക്കുന്നു. അതാണ് നിങ്ങളുടെ കോഡിനുള്ളിൽ സംഭവിക്കുന്നത്! ഫയൽ പോയിന്ററുകളുടെയോ ഫയൽ വായിക്കുന്നതിൽ നിന്ന് കാണുന്നില്ല അല്ലെങ്കിൽ കാണാത്ത ഘട്ടങ്ങൾ എന്നിവ കാരണം പ്രശ്നം സാധ്യതയുണ്ട്.

ഈ ലേഖനത്തിൽ, പ്രശ്നം സൃഷ്ടിക്കുന്നതെന്താണെന്ന് ഞങ്ങൾ തകർക്കും, നിങ്ങളുടെ കോഡ് വിശകലനം ചെയ്ത് സി / ഒ എന്ന ഫയൽ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ശരിയായ മാർഗത്തിലൂടെ നിങ്ങളെ നയിക്കും. അവസാനം, നിങ്ങൾക്ക് വാചക ഫയലുകൾ ആത്മവിശ്വാസത്തോടെ എഴുതാനും വായിക്കാനും കഴിയും അപ്രതീക്ഷിത ആശ്ചര്യങ്ങളില്ലാതെ. പതനം

C- ൽ ഫയൽ കൈകാര്യം ചെയ്യുന്നത് മനസിലാക്കുന്നതെന്തിനാണ് നിങ്ങളുടെ വാചകം ഗിബ്ബരിഷായി മാറുന്നത്

സി ഫയലിനൊപ്പം പ്രവർത്തിക്കുമ്പോൾ, ഡാറ്റ ശരിയായി എഴുതാനും വായിക്കാനും നിർണായകമാണെന്ന് ഉറപ്പാക്കുന്നു. വാചകത്തിന്റെ പ്രശ്നം മാറുന്നു ചൈനീസ് പ്രതീകങ്ങൾ അല്ലെങ്കിൽ വായിക്കാൻ കഴിയാത്ത മറ്റ് ചിഹ്നങ്ങൾ പലപ്പോഴും ഫയൽ പോയിന്ററുകൾ തെറ്റായ കൈകാര്യം ചെയ്യുന്നതിൽ നിന്ന് ഉണ്ടാകുന്നു. ആദ്യ സ്ക്രിപ്റ്റിൽ ഞങ്ങൾ ഒരു ഫയൽ തുറക്കാൻ ശ്രമിച്ചു, അതിൽ "ഹലോ വേൾഡ്" എഴുതുക, തുടർന്ന് അത് തിരികെ വായിക്കുക. എന്നിരുന്നാലും, ഒരു വലിയ തെറ്റ്-ഫയൽ എഴുതിയതിനുശേഷം, മുമ്പത്തെ ഉദാഹരണം ശരിയായി അടയ്ക്കാതെ ഞങ്ങൾ ഇത് റീഡ് മോഡിൽ വീണ്ടും തുറന്നു. ഇത് അപ്രതീക്ഷിത പെരുമാറ്റത്തിന് കാരണമായി, കാരണം രണ്ടാമത്തെ `രണ്ടാമത്തേത് നിങ്ങളുടെ കോൾ ഫയൽ പോയിന്റർ സംഭരിച്ചിട്ടില്ല, നിർവചിക്കാത്ത റീഡ് പ്രവർത്തനത്തിലേക്ക് നയിച്ചു.

ശരിയാക്കിയ സമീപനത്തിൽ, ഓരോ ഫയൽ പ്രവർത്തനവും മികച്ച രീതികൾ പിന്തുടരുന്നുവെന്ന് ഞങ്ങൾ ഉറപ്പാക്കി. പ്രോഗ്രാം ആദ്യം `ഫിന്റ്സ്` ഉപയോഗിച്ച് ഡാറ്റ എഴുതുന്നു, അത് വായിക്കാൻ വീണ്ടും തുറക്കുന്നതിന് മുമ്പ് ഫയൽ അടയ്ക്കുന്നു. ഇത് ഫയൽ പോയിന്ററിന്റെ അഴിമതിയെ തടയുകയും ഡാറ്റ ശരിയായി വായിക്കുകയും ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുന്നു. മറ്റൊരു പ്രധാന മെച്ചപ്പെടുത്തൽ ചേർക്കുകയായിരുന്നു പിശക് കൈകാര്യം ചെയ്യുന്നത് `പെററോ` ഉപയോഗിക്കുന്നു ഒരു ഫയൽ പ്രവർത്തനം പരാജയപ്പെട്ടാൽ, തുടർന്നുള്ള വക്രവ്പരമായ അന്ധമായി ഒരു പിശക് സന്ദേശം അച്ചടിച്ചിരിക്കുന്നു, അത് ഡാറ്റ അഴിമതിയിലേക്കോ ക്രാഷുകളിലേക്കോ നയിച്ചേക്കാം. ഒരു കത്ത് എഴുതാൻ ശ്രമിക്കുന്നത് സങ്കൽപ്പിക്കുകയാണെങ്കിലും പിശകുകൾ പരിശോധിക്കാതെ ഒരു പേന-ഓഹരികൾ എടുക്കാൻ മറക്കുന്നു, ഇത് സമാനമായി ആശയക്കുഴപ്പത്തിലാണ്! പതനം

എഴുത്ത്, വായനയ്ക്കായി പ്രത്യേക പ്രവർത്തനങ്ങൾ അവതരിപ്പിച്ചുകൊണ്ട് ഞങ്ങൾ പ്രോഗ്രാം നടത്തി. ഇത് കോഡ് മോഡുലാർ, വീണ്ടും ഉപയോഗിക്കാവുന്നതാക്കുന്നു, മാത്രമല്ല പ്രവർത്തനം എളുപ്പത്തിൽ ഡീബഗ് ചെയ്യാനും വിപുലീകരിക്കാനും ഞങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു ഹാർഡ് കോഡ് ചെയ്ത സന്ദേശത്തിന് പകരം ഉപയോക്തൃ-ഇൻപുട്ട് വാചകം എഴുതാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, മുഴുവൻ പ്രോഗ്രാമും മാറ്റാതെ ഞങ്ങൾക്ക് `row അലോഫൈയുടെ പ്രവർത്തനം പരിഷ്കരിക്കാനാകും. ഈ മോഡുലാർ സമീപനം ഒരു ബാക്ക്പാക്കിൽ പ്രത്യേക കമ്പാർട്ടുമെന്റുകൾ ഉപയോഗിക്കുന്നത് പോലെയാണ് - ഓരോ ഫംഗ്ഷനും ഒരു നിർദ്ദിഷ്ട ടാസ്ക് കൈകാര്യം ചെയ്യുന്നു, മൊത്തത്തിലുള്ള പ്രോഗ്രാം ക്രമീകരിച്ച് കാര്യക്ഷമവും നിലനിർത്തുക. പതനം

അവസാനമായി, ഒരു `ഒരൊറ്റ` ഫജറ്റുകൾ` വിളിക്കുന്ന ഒരു `ഒരൊറ്റ` ഒരൊറ്റ `എന്ന് കരുതുന്നതിനുപകരം മുഴുവൻ ഫയലും വായിക്കാൻ ഞങ്ങൾ` ലൂപ്പ് ഉപയോഗിച്ചു. മൾട്ടി-ലൈൻ ഫയലുകളുമായി ഇടപെടുമ്പോൾ ഞങ്ങൾക്ക് ഒരു വരിയും നഷ്ടപ്പെടുത്തുന്നില്ല. ശരിയാക്കിയ പ്രോഗ്രാം ഇപ്പോൾ ശരിയായ ഫയൽ ഹാൻഡ്ലിംഗ് ടെക്നിക്കുകൾ പിന്തുടരുന്നു, ഇത് ധരിച്ച വാചകവും തെറ്റായ വായനകളും പോലുള്ള പ്രശ്നങ്ങൾ ഒഴിവാക്കുന്നു. ഘടനാപരമായ പ്രോഗ്രാമിംഗും മികച്ച പരിശീലനങ്ങളും സ്വീകരിക്കുന്നതിലൂടെ, പ്രവചനാതീതമായ പെരുമാറ്റത്തെ ഞാൻ / O സിസ്റ്റമാക്കി മാറ്റുന്നു. പതനം

#include <stdio.h>
#include <stdlib.h>
int main() {
    FILE *fptr;
    fptr = fopen("text.txt", "w"); // Open file in write mode
    if (fptr == ) {
        perror("Error opening file");
        return 1;
    }
    fprintf(fptr, "Hello World\n"); // Write text to file
    fclose(fptr); // Close file

    fptr = fopen("text.txt", "r"); // Open file in read mode
    if (fptr == ) {
        perror("Error opening file");
        return 1;
    }

    char input[100];
    fgets(input, 100, fptr); // Read text from file
    printf("%s", input); // Print read text

    fclose(fptr); // Close file
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
void writeToFile(const char *filename, const char *text) {
    FILE *fptr = fopen(filename, "w");
    if (!fptr) {
        perror("Failed to open file");
        exit(EXIT_FAILURE);
    }
    fprintf(fptr, "%s", text);
    fclose(fptr);
}

void readFromFile(const char *filename) {
    FILE *fptr = fopen(filename, "r");
    if (!fptr) {
        perror("Failed to open file");
        exit(EXIT_FAILURE);
    }
    char buffer[100];
    while (fgets(buffer, sizeof(buffer), fptr)) {
        printf("%s", buffer);
    }
    fclose(fptr);
}

int main() {
    const char *filename = "text.txt";
    writeToFile(filename, "Hello World\n");
    readFromFile(filename);
    return 0;
}

ഫയൽ കൈകാര്യം ചെയ്യുന്നതിലെ കാര്യങ്ങൾ എന്തുകൊണ്ട് എൻകോഡുചെയ്യുന്നു

പോലുള്ള ഒരു പ്രധാന വശം പോലുള്ള ഒരു പ്രധാന വശം ഇതുപോലുള്ള അത്തരം ചൈനീസ് പ്രതീകങ്ങൾ, സിയിൽ ഫയലുകളിലേക്ക് എഴുതുമ്പോൾ എൻകോഡിംഗ് ഉണ്ട്. സ്ഥിരസ്ഥിതിയായി, ഒരു പ്രത്യേക എൻകോഡിംഗ് ഫോർമാറ്റ് ഉപയോഗിച്ച് ടെക്സ്റ്റ് ഫയലുകൾ സംരക്ഷിച്ചു, അത് എല്ലായ്പ്പോഴും പ്രതീക്ഷിച്ചതിനെ പൊരുത്തപ്പെടുന്നില്ല. വിൻഡോസിൽ, നോട്ട്പാഡ് UTF-16 ൽ ഫയലുകൾ സംരക്ഷിച്ചേക്കാം, ഒരു സി പ്രോഗ്രാം സാധാരണയായി യുടിഎഫ് -8 അല്ലെങ്കിൽ ANSI- ൽ എഴുതുന്നു. എൻകോഡിംഗ് പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, വാചകം വായിക്കാൻ കഴിയാത്ത ചിഹ്നമായി ദൃശ്യമാകാം. ഫയൽ വായിക്കുമ്പോൾ എൻകോഡിംഗ് വ്യക്തമായി സജ്ജമാക്കുന്നതിലൂടെ ഈ പൊരുത്തക്കേട് പരിഹരിക്കാൻ കഴിയും, എഴുതിയതും പ്രദർശിപ്പിച്ചിരിക്കുന്നതും തമ്മിലുള്ള പൊരുത്തക്കേട് ഉറപ്പാക്കുന്നു. പതനം

മറ്റൊരു സാധാരണ പ്രശ്നം അത് വീണ്ടും തുറക്കുന്നതിന് മുമ്പ് ഫയൽ ഫ്ലഷ് ചെയ്യുകയോ ശരിയായി അടയ്ക്കുകയോ ചെയ്യുന്നില്ല. ഫയൽ റൈറ്റ് മോഡിൽ തുറന്നിട്ടുണ്ടെങ്കിൽ, ശരിയായ അടയ്ക്കാതെ റീഡ് മോഡിൽ ആക്സസ് ചെയ്യുകയാണെങ്കിൽ, ഉള്ളടക്കം ശരിയായി സംഭരിക്കില്ല. ഇത് ഉൾപ്പെടെ, ഇത് അപ്രതീക്ഷിത ഫലങ്ങളിലേക്ക് നയിച്ചേക്കാം അഴിമതി അല്ലെങ്കിൽ തെറ്റായി വ്യാഖ്യാനിച്ച ഡാറ്റ. ഉപയോഗിക്കുന്നു fclose ഫയൽ വീണ്ടും ആക്സസ് ചെയ്യുന്നതിന് മുമ്പ് എഴുതിയ എല്ലാ ഡാറ്റയും പ്രതിജ്ഞാബദ്ധമാണെന്ന് ഉറപ്പാക്കുന്നു. അതുപോലെ, വിളിക്കുന്നു fflush ഫയൽ അടയ്ക്കുന്നതിന് മുമ്പ് ഏതെങ്കിലും അലിഖിത ഡാറ്റയെ സംരക്ഷിക്കുന്നതിന് സംരക്ഷിക്കുന്നതിന് നിർബന്ധിക്കുന്നു, ഭാഗിക എഴുതുന്ന അല്ലെങ്കിൽ വായിക്കാൻ കഴിയാത്ത ഉള്ളടക്കം തടയുന്നു. പതനം

അവസാനമായി, ഫയൽ തുറക്കുന്ന മോഡുകൾ ഒരു പ്രധാന പങ്ക് വഹിക്കുന്നു. സി, ഒരു ഫയൽ തുറക്കുന്നു "w" നിലവിലുള്ള ഉള്ളടക്കത്തെ മോഡ് തിരുത്തിയെഴുതുക "a" മോഡ് അതിൽ കൂട്ടിച്ചേർക്കുന്നു. ഒരു ഫയൽ അബദ്ധവശാൽ ബൈനറി മോഡിൽ തുറക്കുകയാണെങ്കിൽ ("wb" ഇതിനുപകരമായി "w"), output ട്ട്പുട്ട് വായിക്കാൻ കഴിയാത്ത പ്രതീകങ്ങളായി ദൃശ്യമാകും. ടെക്സ്റ്റ് ഫയലുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ, അപ്രതീക്ഷിത ഫോർമാറ്റിംഗ് പ്രശ്നങ്ങൾ ഒഴിവാക്കാൻ നിങ്ങളുടെ ടെക്സ്റ്റ് എഡിറ്ററിൽ ഫയൽ എൻകോഡിംഗ് പരിശോധിക്കാനും ശുപാർശ ചെയ്യുന്നു.