Problem with dynamic allocation of memory

Question

Until now I did allocate the memory for a matrix like this :

int **p,n;
scanf("%d",&n);
p=malloc(n*sizeof(int));
for(int i=0;i<n;i++)
p[i]=malloc(n*sizeof(int));

but someone told me to do like this :

int **p,n;
scanf("%d",&n);
p=malloc(n*sizeof*p);
for(int i=0;i<n;i++)
p[i]=malloc(n*sizeof*p);

sizeof(p) is not 0 because is not allocated ?? Which one is good ?

This is wrong- `p=malloc(n*sizeof(int));`. It should be- `p=malloc(n*sizeof(int *));`. — H.S., Dec 21 '21 at 11:13
Because `p` is not a pointer to `int` but a pointer to a pointer to `int`. — Gerhardh, Dec 21 '21 at 11:16
The benefit of the second version of the code is exactly that you can avoid such an error. Also if you change type of `p` you don't need to adjust the call to `malloc` — Gerhardh, Dec 21 '21 at 11:17

H.S. · Accepted Answer · 2021-12-21T11:42:08.747

In the first code snippet, this statement is wrong:

p=malloc(n*sizeof(int));

because the type of p is int **, so, p can be pointer to a int * type. It should be:

p = malloc (n * sizeof (int *));
                        ^^^^^

In the second code snippet, allocation to p is correct because of this - sizeof*p. The type of *p is int *. So, sizeof*p is equivalent to sizeof (int *).

But in second code snippet, this is wrong:

p[i]=malloc(n*sizeof*p);

because the type of p[i] is int * i.e. pointer to an int. So, it can point to an integer. Hence, you should allocate memory of n * sizeof (int). It should be

p[i] = malloc (n * sizeof *p[i]);

Here, n * sizeof *p[i] is equivalent to n * sizeof (int) because the type of *p[i] is int.

Its matter of choice to use whichever style you want to. The matter of fact is that, you should have a good understanding of what you are doing and how it works because the lack of understanding can result in mistake in any style that you choose (as you can see there is mistake in both the code snippets you have shown).

This is actually a pretty good example of why each of these styles has its flaws. — Lundin, Dec 21 '21 at 11:34

Lundin · Answer 2 · 2021-12-21T11:22:33.513

First of all, p=malloc(n*sizeof(int)); is wrong - you aren't allocating a 2D array but an array of pointers, each pointing to an array of int. This needs to be p=malloc(n*sizeof(int*)); for the first example to be correct.

Apart from that bug, this is a matter of subjective coding style. Some prefer to write malloc(n*sizeof*p); since sizeof *p gives the size of the pointed-at item. This works because sizeof isn't evaluated for side effects, so no pointer de-referencing actually happens. The size is computed at compile-time.

A third style is also possible: p=malloc( sizeof(int*[n]) );. Here you make it more explicit that you are declaring an array. Which of these three styles to use is subjective and mostly a matter of opinion.

And in case you want to allocate actual 2D arrays allocated adjacently, you need to do as advised here instead: Correctly allocating multi-dimensional arrays

Problem with dynamic allocation of memory

2 Answers2