ಫೈಲ್ output ಟ್‌ಪುಟ್‌ನಲ್ಲಿ ಅನಿರೀಕ್ಷಿತ ಚೀನೀ ಅಕ್ಷರಗಳು: ಡೀಬಗ್ ಮಾಡುವುದು ಸಿ ಫೈಲ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್

ನಿಮ್ಮ ಸಿ ಪ್ರೋಗ್ರಾಂ ಪಠ್ಯದ ಬದಲು ಉದ್ಧಟತನವನ್ನು ಬರೆಯುವಾಗ

ನೀವು ಇದೀಗ ಸಿ ಕಲಿಯಲು ಪ್ರಾರಂಭಿಸಿದ್ದೀರಿ ಮತ್ತು ಫೈಲ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಅನ್ನು ಪ್ರಯತ್ನಿಸಲು ಉತ್ಸುಕರಾಗಿದ್ದೀರಿ. "ಹಲೋ ವರ್ಲ್ಡ್" ಅನ್ನು ಪಠ್ಯ ಫೈಲ್‌ಗೆ ಉಳಿಸಲು ನೀವು ಸರಳ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆಯುತ್ತೀರಿ, ಆದರೆ ನೀವು ಫೈಲ್ ಅನ್ನು ತೆರೆದಾಗ, ಪಠ್ಯವನ್ನು ವಿಚಿತ್ರ ಚೀನೀ ಅಕ್ಷರಗಳಿಂದ ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ. For ಏನು ತಪ್ಪಾಗಿದೆ?

ಈ ವಿಷಯವು ಸಾಕಷ್ಟು ನಿರಾಶಾದಾಯಕವಾಗಿರುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಆರಂಭಿಕರಿಗಾಗಿ. ತಪ್ಪಾದ ಫೈಲ್ ನಿರ್ವಹಣೆ, ದುರುಪಯೋಗಪಡಿಸಿಕೊಂಡ ಕಾರ್ಯಗಳು ಅಥವಾ ಎನ್‌ಕೋಡಿಂಗ್ ಸಮಸ್ಯೆಗಳಿಂದಾಗಿ ಇದು ಹೆಚ್ಚಾಗಿ ಸಂಭವಿಸುತ್ತದೆ. ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸರಿಯಾಗಿ ಓದದಿದ್ದರೆ ಅಥವಾ ಬರೆಯದಿದ್ದರೆ, ಅದು ಡೇಟಾವನ್ನು ಅನಿರೀಕ್ಷಿತ ರೀತಿಯಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು.

ಇಂಗ್ಲಿಷ್‌ನಲ್ಲಿ ಟಿಪ್ಪಣಿ ಬರೆಯುವುದನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ, ಆದರೆ ನೀವು ಅದನ್ನು ಸ್ನೇಹಿತರಿಗೆ ಹಸ್ತಾಂತರಿಸಿದಾಗ, ಅವರು ಅದನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಿನ್ನ ಭಾಷೆಯಲ್ಲಿ ಓದುತ್ತಾರೆ. ನಿಮ್ಮ ಕೋಡ್ ಒಳಗೆ ಅದು ನಡೆಯುತ್ತಿದೆ! ಫೈಲ್ ಪಾಯಿಂಟರ್‌ಗಳ ಅನುಚಿತ ನಿರ್ವಹಣೆ ಅಥವಾ ಫೈಲ್ ಓದುವಲ್ಲಿ ಹಂತಗಳನ್ನು ಕಳೆದುಕೊಂಡಿರುವುದರಿಂದ ಸಮಸ್ಯೆ ಉಂಟಾಗುತ್ತದೆ.

ಈ ಲೇಖನದಲ್ಲಿ, ಸಮಸ್ಯೆಗೆ ಕಾರಣವಾಗುವುದನ್ನು ನಾವು ಒಡೆಯುತ್ತೇವೆ, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸುತ್ತೇವೆ ಮತ್ತು ಫೈಲ್ ಐ/ಒ ಅನ್ನು ಸಿ ಯಲ್ಲಿ ನಿರ್ವಹಿಸಲು ಸರಿಯಾದ ಮಾರ್ಗದ ಮೂಲಕ ನಿಮಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತೇವೆ. ಕೊನೆಯಲ್ಲಿ, ನೀವು ಪಠ್ಯ ಫೈಲ್‌ಗಳನ್ನು ವಿಶ್ವಾಸದಿಂದ ಬರೆಯಲು ಮತ್ತು ಓದಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಅನಿರೀಕ್ಷಿತ ಆಶ್ಚರ್ಯಗಳಿಲ್ಲದೆ. 🚀

ಸಿ ಯಲ್ಲಿ ಫೈಲ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು: ನಿಮ್ಮ ಪಠ್ಯ ಏಕೆ ಉದ್ಧಾರವಾಗುತ್ತದೆ

ಸಿ ಯಲ್ಲಿ ಐ/ಒ ಫೈಲ್ ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಡೇಟಾವನ್ನು ಸರಿಯಾಗಿ ಬರೆಯಲಾಗಿದೆ ಮತ್ತು ಓದುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ನಿರ್ಣಾಯಕ. ಪಠ್ಯವು ಬದಲಾಗುತ್ತಿರುವ ವಿಷಯ ಚೀನೀ ಅಕ್ಷರಗಳು ಅಥವಾ ಫೈಲ್ ಪಾಯಿಂಟರ್‌ಗಳ ತಪ್ಪಾದ ನಿರ್ವಹಣೆಯಿಂದ ಇತರ ಓದಲಾಗದ ಚಿಹ್ನೆಗಳು ಹೆಚ್ಚಾಗಿ ಉದ್ಭವಿಸುತ್ತವೆ. ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ನಾವು ಫೈಲ್ ಅನ್ನು ತೆರೆಯಲು, "ಹಲೋ ವರ್ಲ್ಡ್" ಅನ್ನು ಅದರಲ್ಲಿ ಬರೆಯಲು ಪ್ರಯತ್ನಿಸಿದ್ದೇವೆ ಮತ್ತು ನಂತರ ಅದನ್ನು ಮತ್ತೆ ಓದಿ. ಆದಾಗ್ಯೂ, ಒಂದು ಪ್ರಮುಖ ತಪ್ಪು ಇತ್ತು -ಫೈಲ್‌ಗೆ ಬರೆದ ನಂತರ, ಹಿಂದಿನ ನಿದರ್ಶನವನ್ನು ಸರಿಯಾಗಿ ಮುಚ್ಚದೆ ನಾವು ಅದನ್ನು ರೀಡ್ ಮೋಡ್‌ನಲ್ಲಿ ಮತ್ತೆ ತೆರೆದಿದ್ದೇವೆ. ಇದು ಅನಿರೀಕ್ಷಿತ ವರ್ತನೆಗೆ ಕಾರಣವಾಯಿತು ಏಕೆಂದರೆ ಎರಡನೆಯ `ಫೋಪೆನ್` ಕರೆ ಫೈಲ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಲಿಲ್ಲ, ಇದು ಸ್ಪಷ್ಟೀಕರಿಸದ ಓದುವ ಕಾರ್ಯಾಚರಣೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಸರಿಪಡಿಸಿದ ವಿಧಾನದಲ್ಲಿ, ಪ್ರತಿ ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆಯು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುತ್ತದೆ ಎಂದು ನಾವು ಖಚಿತಪಡಿಸಿದ್ದೇವೆ. ಪ್ರೋಗ್ರಾಂ ಮೊದಲು `fprintf` ಬಳಸಿ ಡೇಟಾವನ್ನು ಬರೆಯುತ್ತದೆ, ನಂತರ ಫೈಲ್ ಅನ್ನು ಓದಲು ಮತ್ತೆ ತೆರೆಯುವ ಮೊದಲು ಅದನ್ನು ಮುಚ್ಚುತ್ತದೆ. ಇದು ಫೈಲ್ ಪಾಯಿಂಟರ್‌ನ ಭ್ರಷ್ಟಾಚಾರವನ್ನು ತಡೆಯುತ್ತದೆ ಮತ್ತು ಡೇಟಾವನ್ನು ಸರಿಯಾಗಿ ಓದುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಮತ್ತೊಂದು ಪ್ರಮುಖ ಸುಧಾರಣೆ ಸೇರಿಸುವುದು ದೋಷ ನಿರ್ವಹಣೆ `ಪೆರೋರ್` ಅನ್ನು ಬಳಸುವುದು. ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆ ವಿಫಲವಾದರೆ, ಮರಣದಂಡನೆಯನ್ನು ಕುರುಡಾಗಿ ಮುಂದುವರಿಸುವ ಬದಲು ದೋಷ ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸಲಾಗುತ್ತದೆ, ಇದು ಡೇಟಾ ಭ್ರಷ್ಟಾಚಾರ ಅಥವಾ ಕ್ರ್ಯಾಶ್‌ಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಪತ್ರ ಬರೆಯಲು ಪ್ರಯತ್ನಿಸುವುದನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ ಆದರೆ ಪೆನ್ ತೆಗೆದುಕೊಳ್ಳಲು ಮರೆತಿದ್ದನ್ನು g ಹಿಸಿ -ದೋಷಗಳನ್ನು ಪರಿಶೀಲಿಸದೆ, ಪ್ರೋಗ್ರಾಂ ಇದೇ ರೀತಿಯ ಗೊಂದಲಮಯ ರೀತಿಯಲ್ಲಿ ವರ್ತಿಸುತ್ತದೆ! 🤯

ಬರವಣಿಗೆ ಮತ್ತು ಓದುವಿಕೆಗಾಗಿ ಪ್ರತ್ಯೇಕ ಕಾರ್ಯಗಳನ್ನು ಪರಿಚಯಿಸುವ ಮೂಲಕ ನಾವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಹೆಚ್ಚು ರಚನಾತ್ಮಕಗೊಳಿಸಿದ್ದೇವೆ. ಇದು ಕೋಡ್ ಮಾಡ್ಯುಲರ್ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದಂತೆ ಮಾಡುತ್ತದೆ, ಇದು ಕ್ರಿಯಾತ್ಮಕತೆಯನ್ನು ಸುಲಭವಾಗಿ ಡೀಬಗ್ ಮಾಡಲು ಮತ್ತು ವಿಸ್ತರಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಾವು ನಂತರ ಹಾರ್ಡ್‌ಕೋಡೆಡ್ ಸಂದೇಶದ ಬದಲು ಬಳಕೆದಾರ-ಇನ್ಪುಟ್ ಮಾಡಿದ ಪಠ್ಯವನ್ನು ಬರೆಯಲು ಬಯಸಿದರೆ, ಇಡೀ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬದಲಾಯಿಸದೆ ನಾವು `ರೈಟ್‌ಟೋಫೈಲ್` ಕಾರ್ಯವನ್ನು ಸರಳವಾಗಿ ಮಾರ್ಪಡಿಸಬಹುದು. . 🎒

ಅಂತಿಮವಾಗಿ, ನಾವು `fgets (...))` ಒಂದು `FGETS` ಕರೆ ಸಾಕು ಎಂದು bone ಹಿಸುವ ಬದಲು ಸಂಪೂರ್ಣ ಫೈಲ್ ಅನ್ನು ಓದಲು ಲೂಪ್ ಅನ್ನು ಬಳಸಿದ್ದೇವೆ. ಬಹು-ಸಾಲಿನ ಫೈಲ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ನಾವು ಯಾವುದೇ ಸಾಲುಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳುವುದಿಲ್ಲ ಎಂದು ಇದು ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ. ಸರಿಪಡಿಸಿದ ಪ್ರೋಗ್ರಾಂ ಈಗ ಸರಿಯಾದ ಫೈಲ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ತಂತ್ರಗಳನ್ನು ಅನುಸರಿಸುತ್ತದೆ, ಕಸವಾದ ಪಠ್ಯ ಮತ್ತು ತಪ್ಪಾದ ಓದುವಿಕೆಗಳಂತಹ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ. ರಚನಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನಾವು ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಯನ್ನು ವಿಶ್ವಾಸಾರ್ಹ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಫೈಲ್ ಐ/ಒ ಸಿಸ್ಟಮ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತೇವೆ. 🚀

#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;
}

ಫೈಲ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್‌ನಲ್ಲಿ ವಿಷಯಗಳನ್ನು ಏಕೆ ಎನ್‌ಕೋಡಿಂಗ್ ಮಾಡುವುದು

ಆಗಾಗ್ಗೆ ಅನಿರೀಕ್ಷಿತ ಚಿಹ್ನೆಗಳನ್ನು ಉಂಟುಮಾಡುವ ಒಂದು ಪ್ರಮುಖ ಅಂಶ, ಉದಾಹರಣೆಗೆ ಚೀನೀ ಅಕ್ಷರಗಳು, ಸಿ ಯಲ್ಲಿ ಫೈಲ್‌ಗಳಿಗೆ ಬರೆಯುವಾಗ ಎನ್‌ಕೋಡಿಂಗ್ ಆಗಿದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ನಿರ್ದಿಷ್ಟ ಎನ್‌ಕೋಡಿಂಗ್ ಸ್ವರೂಪವನ್ನು ಬಳಸಿಕೊಂಡು ಪಠ್ಯ ಫೈಲ್‌ಗಳನ್ನು ಉಳಿಸಲಾಗುತ್ತದೆ, ಅದು ಯಾವಾಗಲೂ ನಿರೀಕ್ಷಿತ ಒಂದಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ. ವಿಂಡೋಸ್‌ನಲ್ಲಿ, ಉದಾಹರಣೆಗೆ, ನೋಟ್‌ಪ್ಯಾಡ್ ಯುಟಿಎಫ್ -16 ರಲ್ಲಿ ಫೈಲ್‌ಗಳನ್ನು ಉಳಿಸಬಹುದು, ಆದರೆ ಸಿ ಪ್ರೋಗ್ರಾಂ ಸಾಮಾನ್ಯವಾಗಿ ಯುಟಿಎಫ್ -8 ಅಥವಾ ಎಎನ್‌ಎಸ್‌ಐನಲ್ಲಿ ಬರೆಯುತ್ತದೆ. ಎನ್ಕೋಡಿಂಗ್ ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೆ, ಪಠ್ಯವು ಓದಲಾಗದ ಚಿಹ್ನೆಗಳಾಗಿ ಕಾಣಿಸಬಹುದು. ಫೈಲ್ ಅನ್ನು ಓದುವಾಗ ಎನ್ಕೋಡಿಂಗ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಹೊಂದಿಸುವ ಮೂಲಕ, ಬರೆಯಲ್ಪಟ್ಟದ್ದು ಮತ್ತು ಪ್ರದರ್ಶಿಸುವ ಯಾವುದರ ನಡುವಿನ ಹೊಂದಾಣಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸುವ ಮೂಲಕ ಈ ಅಸಾಮರಸ್ಯವನ್ನು ಪರಿಹರಿಸಬಹುದು. 📄

ಮತ್ತೊಂದು ಸಾಮಾನ್ಯ ವಿಷಯವೆಂದರೆ ಫೈಲ್ ಅನ್ನು ಮತ್ತೆ ತೆರೆಯುವ ಮೊದಲು ಫ್ಲಶಿಂಗ್ ಅಥವಾ ಸರಿಯಾಗಿ ಮುಚ್ಚುವುದು. ಫೈಲ್ ಅನ್ನು ರೈಟ್ ಮೋಡ್‌ನಲ್ಲಿ ತೆರೆದರೆ ಮತ್ತು ಸರಿಯಾದ ಮುಚ್ಚುವಿಕೆಯಿಲ್ಲದೆ ರೀಡ್ ಮೋಡ್‌ನಲ್ಲಿ ಪ್ರವೇಶಿಸಿದರೆ, ವಿಷಯವನ್ನು ಸರಿಯಾಗಿ ಸಂಗ್ರಹಿಸಲಾಗುವುದಿಲ್ಲ. ಇದು ಸೇರಿದಂತೆ ಅನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು ಭ್ರಷ್ಟ ಅಥವಾ ತಪ್ಪಾಗಿ ಅರ್ಥೈಸಿದ ಡೇಟಾ. ಬಳಸುವುದು fclose ಫೈಲ್ ಅನ್ನು ಮತ್ತೆ ಪ್ರವೇಶಿಸುವ ಮೊದಲು ಎಲ್ಲಾ ಲಿಖಿತ ಡೇಟಾ ಬದ್ಧವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಅದೇ ರೀತಿ, ಕರೆ fflush ಫೈಲ್ ಅನ್ನು ಮುಚ್ಚುವ ಮೊದಲು ಯಾವುದೇ ಅಲಿಖಿತ ಡೇಟಾವನ್ನು ಉಳಿಸಲು ಒತ್ತಾಯಿಸುತ್ತದೆ, ಭಾಗಶಃ ಬರಹಗಳು ಅಥವಾ ಓದಲಾಗದ ವಿಷಯವನ್ನು ತಡೆಯುತ್ತದೆ. 🛠

ಕೊನೆಯದಾಗಿ, ಫೈಲ್ ಓಪನಿಂಗ್ ಮೋಡ್‌ಗಳು ಪ್ರಮುಖ ಪಾತ್ರವಹಿಸುತ್ತವೆ. ಸಿ ಯಲ್ಲಿ, ಇದರೊಂದಿಗೆ ಫೈಲ್ ತೆರೆಯಲಾಗುತ್ತಿದೆ "w" ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ವಿಷಯವನ್ನು ಮೋಡ್ ತಿದ್ದಿ ಬರೆಯುತ್ತದೆ "a" ಮೋಡ್ ಅದಕ್ಕೆ ಸೇರಿಸುತ್ತದೆ. ಫೈಲ್ ಅನ್ನು ಆಕಸ್ಮಿಕವಾಗಿ ಬೈನರಿ ಮೋಡ್‌ನಲ್ಲಿ ತೆರೆದರೆ ("wb" ಬದಲಾಗಿ "w"), output ಟ್‌ಪುಟ್ ಓದಲಾಗದ ಅಕ್ಷರಗಳಾಗಿ ಕಾಣಿಸಬಹುದು. ಪಠ್ಯ ಫೈಲ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ, ಅನಿರೀಕ್ಷಿತ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಸರಿಯಾದ ಮೋಡ್ ಅನ್ನು ಬಳಸಲು ಮತ್ತು ನಿಮ್ಮ ಪಠ್ಯ ಸಂಪಾದಕದಲ್ಲಿ ಫೈಲ್ ಎನ್‌ಕೋಡಿಂಗ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲು ಯಾವಾಗಲೂ ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ.