கோப்பு வெளியீட்டில் எதிர்பாராத சீன எழுத்துக்கள்: பிழைத்திருத்த சி கோப்பு கையாளுதல்

உங்கள் சி நிரல் உரைக்கு பதிலாக அபத்தமானதாக எழுதும்போது

நீங்கள் சி கற்கத் தொடங்கியுள்ளீர்கள், மேலும் கோப்பு கையாளுதலை முயற்சிக்க உற்சாகமாக இருக்கிறீர்கள். உரை கோப்பில் "ஹலோ வேர்ல்ட்" ஐ சேமிக்க ஒரு எளிய நிரலை எழுதுகிறீர்கள், ஆனால் நீங்கள் கோப்பைத் திறக்கும்போது, ​​உரை விசித்திரமான சீன எழுத்துக்களால் மாற்றப்படுகிறது. 🤯 என்ன தவறு?

இந்த பிரச்சினை மிகவும் வெறுப்பாக இருக்கும், குறிப்பாக ஆரம்பநிலைக்கு. தவறான கோப்பு கையாளுதல், தவறாகப் பயன்படுத்தப்பட்ட செயல்பாடுகள் அல்லது குறியாக்க சிக்கல்கள் காரணமாக இது பெரும்பாலும் நிகழ்கிறது. உங்கள் நிரல் சரியாக படிக்கவோ எழுதவோ இல்லை என்றால், அது தரவை எதிர்பாராத வழிகளில் விளக்கக்கூடும்.

ஆங்கிலத்தில் ஒரு குறிப்பை எழுதுவதை கற்பனை செய்து பாருங்கள், ஆனால் நீங்கள் அதை ஒரு நண்பரிடம் ஒப்படைக்கும்போது, ​​அவர்கள் அதை முற்றிலும் மாறுபட்ட மொழியில் படித்தார்கள். உங்கள் குறியீட்டிற்குள் அதுதான் நடக்கிறது! கோப்பு சுட்டிகள் முறையற்ற கையாளுதல் அல்லது கோப்பைப் படிப்பதற்கான படிகளைக் காணவில்லை என்பதன் காரணமாக சிக்கல் இருக்கலாம்.

இந்த கட்டுரையில், சிக்கலை ஏற்படுத்துவதை நாங்கள் உடைப்போம், உங்கள் குறியீட்டை பகுப்பாய்வு செய்து, சி. இல் உள்ள கோப்பு I/O ஐ கையாள சரியான வழியின் மூலம் உங்களுக்கு வழிகாட்டுவோம். முடிவில், நீங்கள் நம்பிக்கையுடன் உரை கோப்புகளை எழுதி படிக்க முடியும் எதிர்பாராத ஆச்சரியங்கள் இல்லாமல். .

சி இல் கோப்பு கையாளுதலைப் புரிந்துகொள்வது: உங்கள் உரை ஏன் அபத்தமானது

C இல் I/O கோப்புடன் பணிபுரியும் போது, ​​தரவு சரியாக எழுதப்பட்டிருப்பதை உறுதிசெய்வது மற்றும் படிக்க முக்கியமானது. உரை பிரச்சினை மாறுகிறது சீன எழுத்துக்கள் அல்லது படிக்க முடியாத பிற சின்னங்கள் பெரும்பாலும் கோப்பு சுட்டிகள் தவறான கையாளுதலிலிருந்து எழுகின்றன. முதல் ஸ்கிரிப்ட்டில், நாங்கள் ஒரு கோப்பைத் திறக்க முயற்சித்தோம், அதில் "ஹலோ வேர்ல்ட்" என்று எழுதினோம், பின்னர் அதை மீண்டும் படித்தோம். எவ்வாறாயினும், ஒரு பெரிய தவறு இருந்தது the கோப்பிற்கு எழுதிய பின்னர், முந்தைய நிகழ்வை சரியாக மூடாமல் அதை வாசிப்பு பயன்முறையில் மீண்டும் திறந்தோம். இது எதிர்பாராத நடத்தையை ஏற்படுத்தியது, ஏனெனில் இரண்டாவது `ஃபோபன்` அழைப்பு கோப்பு சுட்டிக்காட்டி சேமிக்கவில்லை, இது வரையறுக்கப்படாத வாசிப்பு செயல்பாட்டிற்கு வழிவகுக்கிறது.

சரிசெய்யப்பட்ட அணுகுமுறையில், ஒவ்வொரு கோப்பு செயல்பாடும் சிறந்த நடைமுறைகளைப் பின்பற்றுவதை உறுதி செய்தோம். நிரல் முதலில் `fprintf` ஐப் பயன்படுத்தி தரவை எழுதுகிறது, பின்னர் கோப்பை வாசிப்பதற்காக மீண்டும் திறப்பதற்கு முன்பு மூடுகிறது. இது கோப்பு சுட்டிக்காட்டி ஊழலைத் தடுக்கிறது மற்றும் தரவு சரியாக வாசிக்கப்படுவதை உறுதி செய்கிறது. மற்றொரு முக்கிய முன்னேற்றம் சேர்த்தது பிழை கையாளுதல் `பெர்ர்` ஐப் பயன்படுத்துதல். ஒரு கோப்பு செயல்பாடு தோல்வியுற்றால், மரணதண்டனை தொடர்ந்து கண்மூடித்தனமாக மரணதண்டனைக்கு பதிலாக பிழை செய்தி அச்சிடப்படுகிறது, இது தரவு ஊழல் அல்லது செயலிழப்புகளுக்கு வழிவகுக்கும். ஒரு கடிதத்தை எழுத முயற்சிப்பதை கற்பனை செய்து பாருங்கள், ஆனால் ஒரு பேனாவை எடுக்க மறந்துவிடுங்கள் the பிழைகள் சரிபார்க்காமல், நிரல் இதேபோன்ற குழப்பமான முறையில் செயல்படுகிறது! .

எழுதுவதற்கும் வாசிப்பதற்கும் தனித்தனி செயல்பாடுகளை அறிமுகப்படுத்துவதன் மூலம் நிரலை மேலும் கட்டமைக்கப்பட்டதாக மாற்றினோம். இது குறியீட்டை மட்டு மற்றும் மீண்டும் பயன்படுத்தக்கூடியதாக ஆக்குகிறது, இது பிழைத்திருத்த மற்றும் செயல்பாட்டை எளிதாக நீட்டிக்க அனுமதிக்கிறது. எடுத்துக்காட்டாக, ஹார்ட்கோட் செய்திக்கு பதிலாக பயனர் உள்ளீடு செய்யப்பட்ட உரையை எழுத விரும்பினால், முழு நிரலையும் மாற்றாமல் `ரைட் டோஃபைல்` செயல்பாட்டை மாற்றலாம். இந்த மட்டு அணுகுமுறை ஒரு பையுடனும் தனித்தனி பெட்டிகளைப் பயன்படுத்துவதைப் போன்றது - ஒவ்வொரு செயல்பாடும் ஒரு குறிப்பிட்ட பணியைக் கையாளுகிறது, ஒட்டுமொத்த நிரலை ஒழுங்காகவும் திறமையாகவும் வைத்திருக்கிறது. .

இறுதியாக, ஒரு `fgets` அழைப்பு போதுமானதாக இருக்கும் என்று கருதுவதற்கு பதிலாக முழு கோப்பையும் படிக்க ஒரு` (fgets ()) `லூப்பைப் பயன்படுத்தினோம். மல்டி-லைன் கோப்புகளைக் கையாளும் போது நாங்கள் எந்த வரியையும் தவறவிடாமல் இருப்பதை இது உறுதி செய்கிறது. சரிசெய்யப்பட்ட நிரல் இப்போது சரியான கோப்பு கையாளுதல் நுட்பங்களைப் பின்பற்றுகிறது, கவர்ச்சியான உரை மற்றும் தவறான வாசிப்புகள் போன்ற சிக்கல்களைத் தவிர்க்கிறது. கட்டமைக்கப்பட்ட நிரலாக்க மற்றும் சிறந்த நடைமுறைகளை ஏற்றுக்கொள்வதன் மூலம், கணிக்க முடியாத நடத்தையை நம்பகமான மற்றும் பராமரிக்கக்கூடிய கோப்பு I/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;
}

கோப்பு கையாளுதலில் விஷயங்களை குறியாக்கம் செய்வது ஏன்

பெரும்பாலும் எதிர்பாராத சின்னங்களை ஏற்படுத்தும் ஒரு முக்கிய அம்சம் சீன எழுத்துக்கள், C இல் கோப்புகளுக்கு எழுதும்போது குறியாக்கம் செய்யப்படுகிறது. இயல்பாக, உரை கோப்புகள் ஒரு குறிப்பிட்ட குறியாக்க வடிவமைப்பைப் பயன்படுத்தி சேமிக்கப்படுகின்றன, இது எப்போதும் எதிர்பார்க்கப்பட்ட ஒன்றோடு பொருந்தாது. விண்டோஸில், எடுத்துக்காட்டாக, நோட்பேட் யுடிஎஃப் -16 இல் கோப்புகளைச் சேமிக்கக்கூடும், அதே நேரத்தில் சி நிரல் பொதுவாக யுடிஎஃப் -8 அல்லது ஏஎன்எஸ்ஐ இல் எழுதுகிறது. குறியாக்கம் பொருந்தவில்லை என்றால், உரை படிக்க முடியாத சின்னங்களாகத் தோன்றலாம். கோப்பைப் படிக்கும்போது குறியாக்கத்தை வெளிப்படையாக அமைப்பதன் மூலம் இந்த பொருந்தாத தன்மையை தீர்க்க முடியும், எழுதப்பட்டவற்றிற்கும் காண்பிக்கப்படுவதற்கும் இடையில் பொருந்தக்கூடிய தன்மையை உறுதி செய்கிறது. .

மற்றொரு பொதுவான பிரச்சினை கோப்பை மீண்டும் திறப்பதற்கு முன்பு அதை சுத்தப்படுத்தவோ அல்லது சரியாக மூடவோ இல்லை. கோப்பு எழுதும் பயன்முறையில் திறந்து, சரியான மூடல் இல்லாமல் வாசிப்பு பயன்முறையில் அணுகப்பட்டால், உள்ளடக்கம் சரியாக சேமிக்கப்படாது. இது உட்பட எதிர்பாராத முடிவுகளுக்கு வழிவகுக்கும் ஊழல் அல்லது தவறாகப் புரிந்துகொள்ளப்பட்ட தரவு. பயன்படுத்துகிறது fclose கோப்பை மீண்டும் அணுகுவதற்கு முன்பு அனைத்து எழுதப்பட்ட தரவுகளும் செய்யப்படுவதை உறுதி செய்கிறது. இதேபோல், அழைப்பு fflush கோப்பை மூடுவதற்கு முன், எழுதப்படாத தரவை சேமிக்கும்படி கட்டாயப்படுத்துகிறது, பகுதி எழுத்துக்கள் அல்லது படிக்க முடியாத உள்ளடக்கத்தைத் தடுக்கிறது. .

கடைசியாக, கோப்பு திறக்கும் முறைகள் முக்கிய பங்கு வகிக்கின்றன. சி இல், ஒரு கோப்பைத் திறக்கவும் "w" பயன்முறை இருக்கும் உள்ளடக்கத்தை மேலெழுதும் "a" பயன்முறை அதைச் சேர்க்கிறது. ஒரு கோப்பு தற்செயலாக பைனரி பயன்முறையில் திறக்கப்பட்டால் ("wb" அதற்கு பதிலாக "w"), வெளியீடு படிக்க முடியாத எழுத்துக்களாக தோன்றக்கூடும். உரை கோப்புகளை கையாளும் போது, ​​எதிர்பாராத வடிவமைப்பு சிக்கல்களைத் தவிர்க்க சரியான பயன்முறையைப் பயன்படுத்தவும், உங்கள் உரை திருத்தியில் கோப்பு குறியாக்கத்தை சரிபார்க்கவும் எப்போதும் பரிந்துரைக்கப்படுகிறது.