Malloc a large 2D string array in a function outside of main

Question

I have a large dictionary of null terminated strings which will be declared in main as char dictionary[MAX_WORDS][MAX_WORD_LENGTH], where max_words can be 200000 and max word length can be 50. I want to malloc some space for it with another function like:

char ** AllocateMemory (char dictionary[MAX_WORDS][MAX_WORD_LENGTH])
{
    char **p;
    {
        p = (char **)malloc(sizeof(dictionary));
    }
    return p;
}

which will be called in main like

int main (void)
{
char dictionary[MAX_WORDS][MAX_WORD_LENGTH];

dictionary = AllocateMemory(dictionary);
}

Can I access this memory in the normal way? (like another function which loops through words in the dictionary like for (i = 0; dictionary[i][0]; i++), then the letters in each word). Also I may be missing something here but if I malloc space up for it, I have already created a large amount of space in main by having to declare the dictionary anyway? Please correct me I'm sure im just a bit confused here with malloc.

Answer 1

You have multiple problems. The first is that you in main you are declaring dictionary to be an array or arrays which means it's already allocated (the compiler allocates memory for the arrays for you), meaning your assignment is wrong.

Another problem is that the array is probably to large, since most compilers on most systems allocate local variables (including arrays) on the stack, and the stack space is limited. You array of arrays declaration would allocate 200000 * 50 bytes, which is almost 10 MB, far more than most default process stack sizes (on Windows the default stack size if only a single MB).

When you fix the above problems, and make dictionary a pointer to a pointer to char (what AllocateMemory returns) then you have a few other problems. The first is that AllocateMemory allocate the wrong size, and the other is that an array of arrays are not the same as a pointer to a pointer (see this old answer of mine for an explanation). Also, in C you should not cast the result of malloc, or any function returning void *.

---

A "correct" version of your program would look something like this:

char ** AllocateMemory (void)
{
    char **p = malloc(MAX_WORDS * sizeof(*p));
    for (size_t i = 0; i < MAX_WORDS; ++i)
        p[i] = malloc(MAX_WORD_LENGTH + 1);  // +1 for string terminator

    return p;
}

int main (void)
{
    char **dictionary = AllocateMemory();

    // Not you can use `dictionary` as an array of arrays of characters,
    // or an array of strings
}

Answer 2

AllocateMemory can return a pointer of type char (*)[MAX_WORD_LENGTH] as shown below (typedef for simpler understanding)

#include <stdlib.h>

typedef char word[MAX_WORD_LENGTH];
word * AllocateMemory()
{
    word *p;
    {
        p = (word *)malloc(MAX_WORDS*sizeof(word));
    }
    return p;
}

int main (void)
{
    word * dictionary;
    dictionary = AllocateMemory();
    /* Access using dictionary[x][y] */
    return 0;
}

Answer 3

there are several problems with the posted code.

Rather than trying to enumerate them all, I have provided a possible solution to your question.

struct dictionary
{
    char words[MAX_WORDS][ MAX_WORD_LENGTH];
};

struct dictionary *AllocateMemory ()
{
    char *p = NULL;

    if( NULL == (p = malloc( sizeof( struct dictionary ) ) ) )
    { // then malloc failed
        perror( "malloc for dictionary failed ");
        exit( EXIT_FAILURE );
    }

    // implied else, malloc successful

    return p;
}  // end function: AllocateMemory


which will be called in main like

int main (void)
{
    struct dictionary * pDictionary = AllocateMemory();

    free( pDictionary);
    return 0;
}  // end function: main