在C中将（指向整数数组的指针）分配给（指向作为void指针的整数数组的指针）

Question

I have come across a C code similar to the following:

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

int main(void) {

    int *a = malloc(200*sizeof(int));

    int i;

    for (i = 0; i < 200; i++)
    {
      a[i] = i;
    }

    int (*b)[10] = (void*) a;

    printf("\nsizeof(int):\t%d\n", sizeof(int));

    printf("\nb[0]:\t%d\n", b[0]);
    printf("\na:\t%d\n", a);

    printf("\nb[19]:\t%d\n", b[19]);
    printf("\na+190:\t%d\n", a+190);

    printf("\nb[0][8]:\t%d\n", b[0][8]);
    printf("\nb[19][9]:\t%d\n", b[19][9]);

    return 0;
}

As per my understanding, the line int (*b)[10] = (void*) a; is trying to assign pointer b (which is supposed to point to an array of 10 integers) to the starting address of array a typecast as a void pointer. I would have expected b[i] to hold the same data as a[i] for i=0..9 (and any index other than 0 to 9 for b resulting in some undefined behavior). However, the program produces outputs similar to the following sample:

sizeof(int):    4

b[0]:   9768976

a:      9768976

b[19]:  9769736

a+190:  9769736

b[0][8]:        8

b[19][9]:       199

Clearly, b has become an array of 20 pointers, with each elemental pointer pointing to a unique portion of the a array corresponding to 10 integers (or 40 bytes) each. Can someone please explain what exactly int (*b)[10] = (void*) a; does? Specifically, how does the typecast (void *) help in distributing the entire a across multiple elements of b ? The above code would not compile without the (void *) cast.

Answer 1

Look at it like this:

int *a;
a = malloc(200 * sizeof(int));

int (*b)[10];
b = (void *)a;

So, the first line says that a should point to an int . The second line allocates a block of memory that can hold 200 int s, and assigns the address of the start of this block to a . The third line says that b should point to an array of 10 int s. The fourth line says that b should be assigned the address held by a .

So now b points to an array of 10 int s starting at the address returned from the call to malloc() . Since memory was allocated for 200 int s, b points to a block of memory that can hold 20 10-element arrays of int .

The cast to void is needed because a was declared to be a pointer to int ; this allows you to store the value held by a in b , even though they are of different types. I think that this was a mere convenience in the allocation of the appropriate amount of memory for the array. An alternative method, avoiding the declaration of a altogether, would be:

int (*b)[10] = malloc(20 * sizeof(*b));

This second method might or might not seem a bit more cryptic, depending upon the readers tastes. I guess one advantage of the first method is that it allows you to access the elements of the array both sequentially and as a 2d array.

Answer 2

Clearly, b has become an array of 20 pointers, with each elemental pointer pointing to a unique portion of the a array corresponding to 10 integers (or 40 bytes) each.

No, b is just a pointer, not an array. The type b points to is array-of-10- int s. Perhaps this would be simpler if you consider it as:

typedef int row[10]; // A `row` is an array of 10 ints
row* b = (void*) a;

For any pointer T* p , p[n] is sizeof (T) bytes offset from p[n - 1] (assuming that n and n - 1 are valid indices, of course). This case is no different; here T is a 10-element int array, so each element of b is 10 * sizeof (int) bytes away from its adjacent elements.

Specifically, how does the typecast (void *) help in distributing the entire a across multiple elements of b ? The above code would not compile without the (void *) cast.

In C, pointers can be converted between void* and T* without explicit casting. The above case uses a void* cast for convenience by reducing typing; it allows the right-hand-side to be converted to whatever pointer type is needed by the left-hand-side.