NOTE: My examples are not checking for NULL returns from malloc()... you really should do that though; you will crash if you try to use a NULL pointer.

First you have to create an array of char pointers, one for each string (char *):

char **array = malloc(totalstrings * sizeof(char *));

Next you need to allocate space for each string:

int i;
for (i = 0; i < totalstrings; ++i) {
    array[i] = (char *)malloc(stringsize+1);
}

When you're done using the array, you must remember to free() each of the pointers you've allocated. That is, loop through the array calling free() on each of its elements, and finally free(array) as well.

The problem is this:

scanf("%s", &table[i]);

and this:

printf("Person nr %d : %s ", i+1, &table[i]);

You seem to forget that table[i] is a pointer to char which is what a string basically is. By using &table[i] you get a pointer to the pointer, which is of type char **. You basically treat the pointer itself as a string, not the memory it points to.

Simply drop the address-of operator and you can read strings up to five characters (plus the terminator).

Read one character at a time (using getc(stdin)) and grow the string (realloc) as you go.

Here's a function I wrote some time ago. Note it's intended only for text input.

char *getln()
{
    char *line = NULL, *tmp = NULL;
    size_t size = 0, index = 0;
    int ch = EOF;

    while (ch) {
        ch = getc(stdin);

        /* Check if we need to stop. */
        if (ch == EOF || ch == '\n')
            ch = 0;

        /* Check if we need to expand. */
        if (size <= index) {
            size += CHUNK;
            tmp = realloc(line, size);
            if (!tmp) {
                free(line);
                line = NULL;
                break;
            }
            line = tmp;
        }

        /* Actually store the thing. */
        line[index++] = ch;
    }

    return line;
}

just add getchar() after scanf()

so that each '\n' gets disposed of while taking input. Your code will be

int ReadNames(char ***Names, int *n)
{
    int i, k;
    char name[100];
    printf("Enter how many names\n");
    scanf("%d", n);
    getchar(); // eats unnecessary '\n' in the buffer
    /* Allocate memory and read names */
    *Names=(char **)malloc((*n)*sizeof(char *));
    for(i=0;i<(*n);i++)
    {
            *(*Names+i)=(char*)malloc(sizeof(name));
                gets(name);
                    strcpy(*(*Names+i),name);
    }

    for(i=0;i<(*n);i++)
            printf("%s\n",*(*Names+i));
    return 1;
}
void main()
{
    char **Names;
    int n, i;
    ReadNames(&Names, &n);
}

In C a string is a char*. A dynamic array of type T is represented as a pointer to T, so for char* that would be char**, not simply a char* the way you declared it.

The compiler, no doubt, has issued some warnings about it. Pay attention to these warnings, very often they help you understand what to do.

Here is how you can start your testing:

char **aPtr;
int len = 1; // Start with 1 string
aPtr = malloc(sizeof(char*) * len); // Do not cast malloc in C
aPtr[0] = "This is a test";
printf("%s",aPtr[0]); // This should work now.

You use pointers.

Specifically, you use a pointer to an address, and using a standard c library function calls, you ask the operating system to expand the heap to allow you to store what you need to.

Now, it might refuse, which you will need to handle.

The next question becomes - how do you ask for a 2D array? Well, you ask for an array of pointers, and then expand each pointer.

As an example, consider this:

int i = 0;
char** words;
words = malloc((num_words)*sizeof(char*));

if ( words == NULL )
{
    /* we have a problem */
    printf("Error: out of memory.\n");
    return;
}

for ( i=0; i<num_words; i++ )
{
    words[i] = malloc((word_size+1)*sizeof(char));
    if ( words[i] == NULL )
    {
        /* problem */
        break;
    }
}

if ( i != num_words )
{
    /* it didn't allocate */
}

This gets you a two-dimensional array, where each element words[i] can have a different size, determinable at run time, just as the number of words is.

You will need to free() all of the resultant memory by looping over the array when you're done with it:

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

free(words);

If you don't, you'll create a memory leak.

You could also use calloc. The difference is in calling convention and effect - calloc initialises all the memory to 0 whereas malloc does not.

If you need to resize at runtime, use realloc.

• Malloc
• Calloc
• Realloc
• Free

Also, important, watch out for the word_size+1 that I have used. Strings in C are zero-terminated and this takes an extra character which you need to account for. To ensure I remember this, I usually set the size of the variable word_size to whatever the size of the word should be (the length of the string as I expect) and explicitly leave the +1 in the malloc for the zero. Then I know that the allocated buffer can take a string of word_size characters. Not doing this is also fine - I just do it because I like to explicitly account for the zero in an obvious way.

There is also a downside to this approach - I've explicitly seen this as a shipped bug recently. Notice I wrote (word_size+1)*sizeof(type) - imagine however that I had written word_size*sizeof(type)+1. For sizeof(type)=1 these are the same thing but Windows uses wchar_t very frequently - and in this case you'll reserve one byte for your last zero rather than two - and they are zero-terminated elements of type type, not single zero bytes. This means you'll overrun on read and write.  

Addendum: do it whichever way you like, just watch out for those zero terminators if you're going to pass the buffer to something that relies on them.

First you need to understand the difference between the following three declarations. For the sake of brevity, assume N is MAX_WORD_LEN+1 to match your sizing:

char data[N];      // array of N chars
char *data[N];     // array of N char *pointers* (i.e. char *)
char (*data)[N];   // pointer to array of N chars

Remember above all else, pointers are variables that hold an "address" and are implementation-defined. Just like an int variable holds the value of an implementation integer, a pointer variable holds an implementation address.

In almost all cases, you can properly malloc() memory for a pointer type using the sizeof() operator with the underlying target dereferenced. There are some cases where this is not intuitive or easily presentable, but the following should help:

// allocates sizeof(Type) block
Type *p = malloc(sizeof(*p));

// allocates N*sizeof(Type) contiguous blocks
//  note: we'll use this style later to answer your question
Type *pa = malloc(N * sizeof(*pa));

This will work no matter what Type is. This is important, because in your case you have a pointer declared as :

char (*dict)[N];

As we already discussed above, this declares a pointer of type (pointer-to-N-chars). Note that no actual memory has been allocated yet. This is just a pointer; nothing more. Therefore, you can safely allocate a single element using the above syntax as:

// allocate single block
char (*dict)[N] = malloc(sizeof(*dict));

But this only accounts for a single entry. You need len entries, so :

// allocate 'len' contiguous blocks each N chars in size
char (*dict)[N] = malloc(len * sizeof(*dict));

Now dict is safely addressable as an array from 0..(len-1). You can copy in your data such as:

strcpy(data[0], "test");
strcpy(data[1], "another test");

So long as the source string does not exceed N-chars (including the zero-terminator), this will work correctly.

Finally, don't forget to free your allocation when finished:

free(dict);

Spoiler

myDict->dict0 =  malloc( myDict->len * sizeof(*(myDict->dict0)));
myDict->dict1 =  malloc( myDict->len * sizeof(*(myDict->dict1)));