Hi, I have a hard time trying to figure out if the following code works as expected on every platforms available today. I want to make a function that creates a multi-dimensional array of a given type. The function has to be generic. A simple solution is to allocate an array of the wanted size for the base type and another array that we fill with pointers, so we can write: array[i][j][k][l][m] = xx; As you can see array[i] has not the same type as array[i][j]. This is the problem I face. So we would have something like: ----- void *make_matrix(int ndims, int *dims[], size_t elem_size) { void *pointers; void *data; int nb_pointers = get_nb_pointers(ndims, dims); int matrix_size = get_matrix_size(ndims, dims); pointers = malloc(nb_pointers * sizeof(void *)); //and we check data = malloc(matrix_size * elem_size); //and we check //and we populate pointers in loops doing the following //pointers' manipulations: { void **cur = pointers; void **head = cur + something; //something is an integer *cur = head; } //and for the last dimension, we have also a loop manipulating //pointers as in: { char *p = data; void **cur = pointers; *cur = p + something; //something is an int, multiple of elem_size } return pointers; } ----- So we treat every pointers in the pointers' array as "void *" and we pretend that "void *" is like "void **" and like "void ***" and so on. And also like "base_type *" which we don't know but simply pass its size to make_matrix as sizeof(base_type). I tried to read C99 (with n1336.pdf) but I can't figure out why this is not c99. I found a message titled "Multi-Dimensional Dynamic Arrays" from Oct 20 1998 on comp.lang.c that says something like "pointers of type double * may not be the same beast as pointers of type int * just like a double is not the same in memory as an int." What does it refer to in the c99 document? (or the draft I have, n1336.pdf) Sure I could ask on comp.lang.c, but people there are more interested in abstract c99 policies. I care about writing a function. And I care about how generic it would be. It works on my x86 hosts and using gcc. My real concern is: are there platforms where the code miserably fails? That would help my poor intuitive brain. So, are there platforms out there where different pointers' types are indeed different, so that you can't use the address of a double * to point to an int? I know there are alignment issues, but apart from that? Are there some pointers that are, I don't know, 32 bits for a double * and 48 bits or whatever for an int *? Since gcc is a C compiler available for many many platforms, you are probably the best qualified to answer my questions. And some of you surely know very well dark corners of the c99 specifications, which is very weird in some cases. And they don't explain why they go so convoluted. There must be reasons, no? Why do something almost impossible to understand if some platforms out there don't behave weird? So if you have some time to answer me, that would be hackingly cool. (Or any URL where all this is crystal clear...) As a last question, if we move away from c99 per se and focus on real implementations, how does gcc behaves with my code above? Is it doing the expected thing? on every backend you have? Thanks, and sorry if this is the wrong mailing list for such questions. People writing gcc (you) just seem qualified enough people to enlight a poor lost brain like mine (without removing my skull if possible). Cédric.