尝试从文件中读取单词列表并将其存储到C语言的数组中

Question

my goal is to read my text file "dictionary.txt" line by line and save all the words in it to my array called words for now and would like to print it to make sure the array contains everything but I'm pretty new to C and not sure how to go about it. The program just crashes when I try to run it and not sure why.
(it is a rather large text file that contains 149256 words with the longest word being 20 characters)

edit: I would like to have the array dynamically allocated, not sure if this is how to do it.

#include <stdio.h>
#include <stdlib.h>
#define listlength 149256
#define wordslength 21


char** getwords(int rows, int col);
void freeArray(char** words, int rows);

int main(){

    int i,j, numCases;
    char** words = getwords(listlength, wordslength);
    //test to see if the words array is saving correctly

    for(i=0;i<20;i++){
        printf("%s", words[i]);
    }

    //Get number of cases.
    //printf("enter number of cases:\n");
    //scanf("%d", &numCases);
    //Process each case.

    freeArray(words, listlength);

}


char** getwords(int rows, int col){

    //allocate top level of pointers.

    char** words = malloc(sizeof(char*)*rows);
    int i;
    FILE *dictionary;

    //allocate each individual array
    for(i=0; i<rows; i++){
        words[i] = malloc(sizeof(char)*col);
    }
        //read dictionary.txt
    for(i=0; i<rows; i++){
        FILE *dictionary = fopen("dictionary.txt", "r");
        fgets(words[i],wordslength,dictionary);
    }

    fclose(dictionary);
    return words;
}

void freeArray(char** words, int rows){

    int i;
    for(i=0; i<rows; i++){
        free(words[i]);
    }
    free(words);
}

Answer 1

Ok I think that instead of listing all the errors in here ;), I will just rewrite the getwords function for you and hopefully teach you along the way. Note that I am making some assumptions here. I assume that the file has one word per line and the maximum length is the cols parameter. To start, I would change the parameter name to maxWordLen instead of cols (this is clearer) and getwords to getWords (this is convention). Making the function signature like so:

char** getWords(int rows, int maxWordLen)

You can straight up get rid of these two lines:

int i;
FILE *dictionary;

For allocating, you need to include space for the null character at the end of every string.

//   VVV put declaration here (on others as well)
for (int i = 0; i < rows; i++) {
    words[i] = malloc(sizeof(char) * (maxWordLen + 1));
    //                                          ^^^^
}

DO NOT OPEN THE FILE MULTIPLE TIMES!!! Your code:

for(i=0; i<rows; i++){
    FILE *dictionary = fopen("dictionary.txt", "r");
    fgets(words[i],wordslength,dictionary);
}

Not only will it not work, because it starts at the top of the file every time, is bad practice and is very memory inefficient. Do this instead:

FILE* dictionary = fopen("dictionary.txt", "r");

for (int i = 0; i < rows; i++) {
    fgets(words[i], maxWordLen + 1, dictionary);
}

The last two line are good just finish up with closing the file and return words . Whew! Here's a condensed code snippet of all that ;):

char** getWords(int rows, int maxWordLen) {
    char** words = malloc(sizeof(char*) * rows);

    for (int i = 0; i < rows; i++) {
        words[i] = malloc(sizeof(char) * (maxWordLen + 1));
    }

    FILE* dictionary = fopen("dictionary.txt", "r");

    for (int i = 0; i < rows; i++) {
        fgets(words[i], maxWordLen + 1, dictionary);
    }

    fclose(dictionary);

    return words
}

Now I haven't tested this code, so it might have some typos, but hopefully this helps!

Answer 2

You were having a bit of difficulty determining what is important to pass to getwords . While you can embed/hardcode a filename in the function, that really defeats the purpose of creating a flexible re-usable routing. When you think about what the functions needs, it needs (1) a FILE* stream to read from; (2) a way to return the number of words read into your pointer-to-pointers to strings; and (3) it must return the pointer. That way you get back, your newly allocated list of words and know how many there are.

Your use of fgets was a bit awkward. Since you have defined the wordslength as 21 , you can simply statically declare a buffer (say buf ) of wordslength + 1 to use with fgets and then allocate/copy to words[i] . This allows you to insure you have a valid string in buf before you allocate memory.

Lastly, there is a realloc function that makes is unnecessary to allocate all 149256 pointers at once. (if you know that is how many you will have, that's fine) As a general rule, start with some reasonable expected amount and then realloc additional pointers when your limit is reached and keep going.

Here is a quick rewrite putting the pieces together:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define listlength 256
#define wordslength 21

char **getwords (FILE *fp, int *n);
void free_array (char** words, int rows);

int main (int argc, char **argv) {

    int i, nwords = 0;
    char **words = NULL;  /* file given as argv[1] (default dictionary.txt) */
    char *fname = argc > 1 ? argv[1] : "dictionary.txt";
    FILE *dictionary = fopen (fname, "r");

    if (!dictionary) { /* validate file open */
        fprintf (stderr, "error: file open failed.\n");
        return 1;
    }

    if (!(words = getwords (dictionary, &nwords))) {
        fprintf (stderr, "error: getwords returned NULL.\n");
        return 1;
    }
    fclose(dictionary);

    printf ("\n '%d' words read from '%s'\n\n", nwords, fname);

    for (i = 0; i < nwords; i++) {
        printf ("%s\n", words[i]);
    }

    free_array (words, nwords);

    return 0;
}

/* read all words 1 per-line, from 'fp', return
 * pointer-to-pointers of allocated strings on 
 * success, NULL otherwise, 'n' updated with 
 * number of words read.
 */
char **getwords (FILE *fp, int *n) {

    char **words = NULL;
    char buf[wordslength + 1] = {0};
    int maxlen = listlength > 0 ? listlength : 1;

    if (!(words = calloc (maxlen, sizeof *words))) {
        fprintf (stderr, "getwords() error: virtual memory exhausted.\n");
        return NULL;
    }

    while (fgets (buf, wordslength + 1, fp)) {

        size_t wordlen = strlen (buf);  /* get word length */

        if (buf[wordlen - 1] == '\n')   /* strip '\n' */
            buf[--wordlen] = 0;

        words[(*n)++] = strdup (buf);   /* allocate/copy */

        if (*n == maxlen) { /* realloc as required, update maxlen */
            void *tmp = realloc (words, maxlen * 2 * sizeof *words);
            if (!tmp) {
                fprintf (stderr, "getwords() realloc: memory exhausted.\n");
                return words; /* to return existing words before failure */
            }
            words = tmp;
            memset (words + maxlen, 0, maxlen * sizeof *words);
            maxlen *= 2;
        }
    }

    return words;
}

void free_array (char **words, int rows){

    int i;
    for (i = 0; i < rows; i++){
        free (words[i]);
    }
    free(words);
}

Example Use/Output

$ ./bin/dict ../dat/10int_nl.txt

 '10' words read from '../dat/10int_nl.txt'

8572
-2213
6434
16330
3034
12346
4855
16985
11250
1495

Memory Error Check

In any code your write that dynamically allocates memory, you have 2 responsibilites regarding any block of memory allocated: (1) always preserves a pointer to the starting address for the block of memory so, (2) it can be freed when it is no longer needed.

It is imperative that you use a memory error checking program to insure you haven't written beyond/outside your allocated block of memory, attempted to read or base a jump on an unintitialized value and finally to confirm that you have freed all the memory you have allocated.

For Linux valgrind is the normal choice. There are many subtle ways to misuse a new block of memory. Using a memory error checker allows you to identify any problems and validate proper use of of the memory you allocate rather than finding out a problem exists through a segfault . There are similar memory checkers for every platform. They are all simple to use, just run your program through it.

$ valgrind ./bin/dict ../dat/10int_nl.txt
==10212== Memcheck, a memory error detector
==10212== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.
==10212== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info
==10212== Command: ./bin/dict ../dat/10int_nl.txt
==10212==

 '10' words read from '../dat/10int_nl.txt'

8572
-2213
<snip>
11250
1495
==10212==
==10212== HEAP SUMMARY:
==10212==     in use at exit: 0 bytes in 0 blocks
==10212==   total heap usage: 15 allocs, 15 frees, 863 bytes allocated
==10212==
==10212== All heap blocks were freed -- no leaks are possible
==10212==
==10212== For counts of detected and suppressed errors, rerun with: -v
==10212== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)

Always confirm All heap blocks were freed -- no leaks are possible and equally important ERROR SUMMARY: 0 errors from 0 contexts .

Note on strdup

Since strdup allocates memory (as well as copies the given string), you should check the return just as you would with malloc or calloc to protect against memory exhaustion. eg:

    if (!(words[(*n)++] = strdup (buf))) {
        fprintf (stderr, "getwords() error: virtual memory exhausted.\n");
        return NULL;
    }