如何创建一个二维数组来存储从 C 中的 a.txt 文件扫描的单词集合？

Question

I am working on a program where I want to scan a.txt file that contains a poem. After scanning the poem, I want to be able to store each individual word as a single string and store those strings in a 2D array. For example, if my.txt file contains the following:

Haikus are easy.
But sometimes they don't make sense.
Refrigerator.

I want to be able to store each word as the following in a single array:

H a i k u s \0
a r e \0
e a s y . \0
B u t \0
s o m e t i m e s \0
t h e y \0
d o n ' t \0
m a k e \0
s e n s e . \0
R e f r i g e r a t o r . \0

So far, this is the code I have. I am having difficulties understanding 2D arrays, so if someone could explain that to me as well in context to this problem, that would be great. I am still learning the C language, so it takes time for me to understand some things. I have been scratching my head at this for a few hours now and am using this as help after trying everything I could think of!

The following is my function for getting the words and storing them in to arrays (it also returns the number of words there are, which is used separately for a different part of the program):

int getWords(int maxSize, FILE* inFile, char strings[][COL_SIZE]){
    int numWords;
    for(int i = 0; i < maxSize; i++){
        fscanf(inFile, "%s", strings[i]);
        while(fscanf(inFile, "%s", strings[i] == 10){
            numWords++;
        }
    }
    return numWords;
}

Here's the code I have where I call the function in the main function (I am not sure what numbers to set the COL_SIZE and MAX_LENGTH to, like I said, I am new to this and am trying my best to understand 2D arrays and how they work):

#define COL_SIZE 10
#define MAX_LENGTH 500

int main(){
    FILE* fp;
    char strArray[MAX_LENGTH][COL_SIZE];

    fp = fopen(FILE_NAME, "r");
    if(fp == NULL){
        printf("File could not be found!");
    }
    else{
        getWords(MAX_LENGTH, fp, strArray);
        fclose(fp);
    }
    return 0;
}

Answer 1

What you are not understanding, it that COL_SIZE must be large enough to store the longest word +1 for the nul-terminating character. Take:

R e f r i g e r a t o r . \0
----------------------------
1 2 3 4 5 6 7 8 9 0 1 2 3 4    - >  14 characters of storage required

You declare a 500 x 10 2D array of char :

char strArray[500][10]

"Refrigertator." cannot fit in strArray , so what happens is "Refrigerat" is stored at one row-index, and then "tor.\0" overwrites the first 5 characters of the next.

There are a number of ways to handle the input, but if you want to use fscanf , then you need (1) to include a field-width modifier with the string conversion to limit the number of characters stored to the amount of storage available, and (2) validate the next character after those you have read is a whitespace character, eg

#include <ctype.h>

int getWords(int maxSize, FILE* inFile, char strings[][COL_SIZE])
{
    char c;
    int n = 0;
    
    while (n < maxSize) {
        int rtn = fscanf (inFile, "%9s%c", strings[n], &c);
        if (rtn == 2 && isspace(c))
            n++;
        else if (rtn == 1) {
            n++;
            break;
        }
        else
            break;
    }
    
    return n;
}

Note the format string contains a field-width modifier of one-less than the total number of characters available, and then the character conversion stores the next character and validates it is whitespace (if it isn't you have a word that is too long to fit in your array)

With any user-input function, you cannot use it correctly unless you check the return . Above, the return from fscanf() is saved in rtn . If you have a successful conversion of both your string limited to COL_SIZE - 1 by your field-width modifier and c is whitespace, you have a successful read of the word and you are not yet at EOF . If the return is 1 , you have the successful read of the word and you have reached EOF (non-POSIX line end on last line). Otherwise, you will either reach the limit of MAX_LENGTH and exit the loop, or your will reach EOF and fscanf() will return EOF forcing an exit of the loop through the else clause.

Lastly, don't skimp on buffer size. The longest word in the non-medical unabridged dictionary is 29-character, requiring a total of 30 characters storage, so #define COL_SIZE 32 makes more sense than 10 .

Look things over and let me know if you have more questions.

---

stdio.h Only

If you are limited to stdio.h , then you can manually confirm that c contains a whitespace character:

        if (rtn == 2 && (c == ' ' || c == '\t' || c == '\n'))
            n++;

Answer 2

You probably don't want a traditional 2D array. Those are usually rectangular, which is not well suited to storing variable length words. Instead, you would want an array of pointers to buffers, sort of like argv is. Since the goal is to load from a file, I suggest using a contiguous buffer rather than allocating a separate one for each word.

The general idea is this:

1. First pass: get total file size and read in the whole thing (+1 byte for trailing NUL).
2. Second pass: count the words and split them with NULs.
3. Third pass: allocate a buffer for the word pointers and fill it in

Here's how to load the entire file:

#include <sys/stat.h>
#include <stdlib.h>
#include <stdio.h>

char *load_file(const char *fname, int *n)
{
    struct stat st;
    if(stat(fname, &st) == -1 || st.st_size == 0) return NULL;
    char *buffer = malloc(st.st_size + 1);
    if(buffer == NULL) return NULL;
    FILE *file = fopen(fname, "r");
    if(file == NULL || fread(buffer, 1, st.st_size, file)) {
        free(buffer);
        buffer = NULL;
    }
    fclose(file);
    *n = st.st_size;
    return buffer;
}

You can count the words by just stepping through the file contents and marking the end of each word.

#include <ctype.h>

char *skip_nonword(char *text, char *end)
{
    while(text != end && !isalpha(*text)) text++;
    return text;
}

char *skip_word(char *text, char *end)
{
    while(text != end && isalpha(*text)) text++;
    return text;
}

int count_words(char *text, int n)
{
    char *end = text + n;
    int count = 0;
    while(text < end) {
        text = skip_nonword(text, end);
        if(text < end) {
            count++;
            text = skip_word(text, end);
            *text = '\0';
        }
    }
    return count;
}

Now you are in position to allocate the word buffer and fill it in:

char **list_words(const char *text, int n, int count)
{
    char *end = text + n;
    char **words = malloc(count * sizeof(char *));
    if(words == NULL) return NULL;
    for(int i = 0; i < count; i++) {
        words[i] = skip_nonword(text, end);
        text = skip_word(words[i], end);
    }
    return words;
}