C语言中的多维数组

Question

It is related to comments for my answer in this question: How to turn 2d array out of 1d one?

So, consider this snippet:

int M = 5;
int N = 5;

int** theArray = (int**) malloc(M*sizeof(int*));  

for (int i = 0; i < M; i++)
{
    theArray[i] = (int*) malloc(N*sizeof(int));

    for(int j = 0 ; j < N; j++)
    {
        theArray[i][j] = i+j;
        printf("%d ", theArray[i][j]);
    }

    printf("\n");
}

for (int k = 0; k < M; k++)
{  
   free(theArray[k]);  
}
free(theArray);

I gotta say that it works perfectly fine on my machine, but I was told in comments that it is pure luck and it is wrong way to declare 2-dimensional array, that memory should be allocated with only 1 malloc to get contiguous memory.

I'm genuinely perplexed, because I thought that non-dynamic multidimensional arrays in C works exactly the same way: they are basically an array of pointers, where each value is an array.

The question is, is it right (portable, common practice etc) way to do this? Did I miss something on this topic? I mean, I really don't see any problem with this code.

EDIT:

I got the answer which I finally understood from comments by WhozCraig and Daniel Fischer. My main mistake was that I assumed that arrays and pointers are more alike than they really are.

Main reason is row-major order in which actual multidimensional arrays are stored in linear memory ( http://en.wikipedia.org/wiki/Row-major_order ). And to understand practical difference between real multidimensional arrays and my snipppet I suggest reading this article (it made nice clarification on this topic for me and provdes easy to understand examples):

Part 1: http://eli.thegreenplace.net/2009/10/21/are-pointers-and-arrays-equivalent-in-c/

Part 2: http://eli.thegreenplace.net/2010/04/06/pointers-vs-arrays-in-c-part-2d/

Answer 1

Compare this code:

int array[10][10];

for (int i = 0; i < 10 * 10; i++) {
   *((int *)array+i) = 0;
}

This is fine for a two dimensional array, as all of the memory is contiguous. With your version, you have a contiguous set of pointers, each of which could be pointing anywhere in memory.