C语言读取文件查找最长单词程序卡顿问题求助

Hey there! Let's break down what's causing your program to stall at those specific iterations and fix the other bugs tripping you up. You were on the right track suspecting realloc issues, but there are a few key mistakes in memory handling and indexing creating chaos.

Critical Bugs in Your Code: #

• Array Index Out-of-Bounds: When you run s = realloc(s, i*sizeof(char)) then s[i] = c, you're writing past the end of the allocated array. C arrays are 0-indexed—if you allocate i characters, valid indices are 0 to i-1. This memory corruption is almost certainly causing the weird stalls and unpredictable behavior.
• Broken realloc Error Handling: Your while(longestWord == NULL) loop is a death trap if memory allocation fails—it'll run forever. Worse, you never check if realloc for s fails, which would lose the original pointer and cause memory leaks or crashes.
• Missing Null Terminators: You never add '\0' to the end of s or longestWord. C strings require this terminator to print correctly; without it, you'll get garbage characters or undefined behavior.
• Missing Header File: isalpha is defined in <ctype.h>—not including this header can lead to unexpected behavior (since the compiler might misinterpret the function's return type).
• Unnecessary Global Variables: Variables like fptr, c, and iteration don't need to be global. Keeping them inside main makes your code cleaner and avoids accidental side effects.

Fixed Code with Explanations: #

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h> // Added for isalpha function

int main() {
    FILE* fptr = fopen("C:\\....\\input", "r");
    if (fptr == NULL) { // Added check for file open failure
        printf("Failed to open file!\n");
        return 1;
    }

    int c;
    int iteration = 0;
    char *s = malloc(sizeof(char));
    char *longestWord = malloc(sizeof(char));
    int i = 1, charCount = 0;

    // Initialize strings with null terminators to avoid garbage data
    *s = '\0';
    *longestWord = '\0';

    while((c = fgetc(fptr)) != EOF) {
        iteration++;
        printf("Iteration %d\n", iteration);

        if (isalpha(c) != 0) {
            // Use temp pointer to safely check realloc success
            char *temp = realloc(s, i * sizeof(char));
            if (temp == NULL) {
                printf("Memory allocation failed for current word!\n");
                free(s);
                free(longestWord);
                fclose(fptr);
                return 1;
            }
            s = temp;
            s[i-1] = c; // Fixed index: write to valid position
            i++;
            s[i-1] = '\0'; // Add null terminator to keep string valid
        }
        else if(c == ' ' || c == '\n') {
            // Compare current word length (i-1) to longest recorded
            if((i-1) > charCount) {
                charCount = i-1;
                char *temp = realloc(longestWord, i * sizeof(char));
                if (temp == NULL) {
                    printf("Memory allocation failed for longest word!\n");
                    free(s);
                    free(longestWord);
                    fclose(fptr);
                    return 1;
                }
                longestWord = temp;
                // Copy current word to longestWord
                for(int t = 0; t < i; t++) {
                    longestWord[t] = s[t];
                }
            }
            i = 1;
            *s = '\0'; // Reset current word to empty string
        }
        else {
            printf("\n\n********Error, unrecognized character encountered********\n\n");
        }
    }

    // Handle the final word if file ends without a space/newline
    if((i-1) > charCount) {
        charCount = i-1;
        char *temp = realloc(longestWord, i * sizeof(char));
        if (temp == NULL) {
            printf("Memory allocation failed for longest word!\n");
            free(s);
            free(longestWord);
            fclose(fptr);
            return 1;
        }
        longestWord = temp;
        for(int t = 0; t < i; t++) {
            longestWord[t] = s[t];
        }
    }

    printf("%d characters in longest word: %s\n", charCount, longestWord);

    free(s);
    free(longestWord);
    fclose(fptr);
    return 0;
}

Key Improvements: #

1. File Open Validation: The program now exits gracefully if the input file can't be opened, instead of crashing.
2. Safe Memory Allocation: Using a temporary pointer for realloc ensures we don't lose the original pointer if allocation fails, preventing memory leaks.
3. Correct Indexing: We now write to s[i-1] instead of s[i], staying within the bounds of allocated memory.
4. Proper String Termination: Null terminators are added to keep all strings valid, ensuring correct printing.
5. Final Word Handling: The original code missed the last word if the file ended without a space/newline—this fix addresses that edge case.
6. Cleaner Variable Scope: All variables are now contained within main for better code organization.

With these fixes, your program will no longer stall at those iterations and will correctly output:

17 characters in longest word: abcdefghijklmnopq

Keep experimenting and debugging—those small memory details are tricky for beginners, but you're already doing great by tracking iterations and suspecting the right areas!

内容的提问来源于stack exchange，提问作者RobinH