“实”数组指针和 malloc

Question

So I was just playing around with Array pointers to see how they work, my example below allocates space for 2 array pointers to an array with 10 ints.

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

int main(void) {
    int (*p)[10] = malloc(sizeof(int[10]) * 2);

    for (int arrayI = 0; arrayI < 2; ++arrayI) {
        for (int i = 0; i < 10; ++i) {
            p[arrayI][i] = (arrayI+1) * i;
        }
    }

    for (int arrayI = 0; arrayI < 2; ++arrayI) {
        for (int i = 0; i < 10; ++i) {
            printf("%d\n", p[arrayI][i]);
        }
        printf("\n");
    }
}

This seems to work fine and gives me:

C:\Users\USERNAME\Desktop>gcc -Wall -Wextra --std=c18 a.c && a.exe
0
1
2
3
4
5
6
7
8
9

0
2
4
6
8
10
12
14
16
18

For my question, you rarely see code like this, if at all. Is there anything dangerous with doing things like this or is it just "bad code". And again, this is just me playing around with Array pointers.

Answer 1

Is there anything dangerous with doing things like this or is it just "bad code".

No. This is actually a correct way of making a dynamic allocated 2D array.

Instead of

int (*p)[10] = malloc(sizeof(int[10]) * 2);

I prefer

int (*p)[10] = malloc(2 * sizeof *p);

As p is a pointer to an array of 10 ints, *p is an array of 10 ints.

Many prefer to have an explicit release of memory. It's not required as the program terminates anyway. It's opinion based but I would add:

free(p);
return 0;

at the end of the program.

Answer 2

my example below allocates space for 2 array pointers to an array with 10 ints

No, this is one array pointer int (*p)[10] . This gives 2 arrays: sizeof(int[10]) * 2 .

Is there anything dangerous with doing things like this

The only danger is the obscure de-referencing syntax. The most correct way to write your example is this:

 int (*p)[2][10] = malloc(sizeof(int[2][10]));

or equivalent

 int (*p)[2][10] = malloc(sizeof *p);

But if you do that, you have to write the strange-looking (*p)[i][j] when de-referencing. Therefore we drop the left-most dimension, a "manual array decay", and get a int (*)[10] which is actually a pointer to the first element in a int[2][10] array. If you want, you could also rewrite the code as:

int (*arr)[2][10] = malloc(sizeof *arr);
int (*p)[10] = *arr;

Also, you should always free the allocated memory, since free will often result in a crash in case you have any lurking pointer corruption bugs somewhere in the program.