Dynamic Memory Allocation with pointer of arrays

Question

How to dynamically allocation memory for pointer of array? (*p)[4]

int main()
{
    int (*p)[4];
    int i;
    for (i=0;i<4;i++)
       (p)[i]=(int*)malloc(4);
    printf("a");
    return 0;
} 

on code::blocks, it says:

error: incompatible types when assigning to type 'int[4]' from type 'int *'|

Answer 1

You are mixing a pointer to an array of integers (your declaration) with an array of integer pointers (the assignment). You can either change your declaration to:

int *p[4];

In which case your assignment will work. Or, you can simply remove the malloc since your declaration as it stands already has four integers allocated. However, if you want the integers as an automatic the code would be more readable if the declaration were:

int p[4];

Since that's basically the same thing. You can just pass in &p if you want a pointer to an array of integers later on.

Answer 2

In your declaration int (*p)[4];, p is a pointer to array of int type and 4 length, but p is just a pointer it doesn't point to any array. So you can assign to (*p)[i].

Notice parenthesis around *p is needed as precedence of [] operator is higher then * deference operator. So (p)[i] is very wrong.

First understand how to use pointer to array check following example:

#include<stdio.h>
int main(){
  int b[4] = {1, 2, 3, 4}; 
  int  i;
  int (*p)[4] = &b;
  for(i = 0; i < 4; i++){
     printf(" b[%d] = (*p)[%d] = %d\n", i, i, (*p)[i]);
  }
  return 1;
}

Output:

 b[0] = (*p)[0] = 1
 b[1] = (*p)[1] = 2
 b[2] = (*p)[2] = 3
 b[3] = (*p)[3] = 4

Check working code @codepad.

Now, How can you use dynamic memory allocation for p pointer? Check following example:

#include<stdio.h>
#include<stdlib.h>
int main(){
  int  i;
  int (*p)[4];
  p = malloc(4 * sizeof(int)); // allocation 
  // assignments 
  for(i = 0; i < 4; i++){
    (*p)[i] = i * i;
  }
  for(i = 0; i < 4; i++){
     printf(" (*p)[%d] = %d\n", i, (*p)[i]);
  }
  return 1;
}   

compile it as: gcc -Wall -pedantic xx.c check code working @codepad.

I would suggest you avoid casting returned address from malloc and calloc functions in C, regarding this read Do I cast the result of malloc?.

Answer 3

If you are just allocating a 4-element array of int, you'd write

int (*p)[4] = malloc( sizeof *p );

or

int (*p)[4];
...
p = malloc( sizeof *p );

Since the type of p is "pointer to 4-element array of int", the type of the expression *p is "4-element array of int", so sizeof *p gives us the right number of bytes to allocate (sizeof (int [4])).

You'd access each element as

(*p)[i] = x; 

The parentheses are necessary. Remember that the type of the expression *p is "4-element array of int", so we want to apply the [] operator to the result of that expression. Since [] has higher precedence than unary *, we need to explicitly group the * operator to p with the parentheses.

You could also write p[0][i] = x, since p[0] is synonymous with *p. This gets rid of the explicit dereference, but it treats p as a 2D array, which may be confusing.

Because of that confusion, this isn't the usual way of allocating a 1D array; the usual practice is to write

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

Since the type of p is "pointer to int", the type of the expression *p is simply int, so we need to specify the number of ints we want in the malloc call. Since p is a simple pointer to int, we can apply the subscript operator to it directly without having to dereference it first.

If you're allocating an Nx4-element array of int, you'd write

int (*p)[4] = malloc ( N * sizeof *p );

and you'd access each element as

p[i][j] = x;

Since the type of the expression p is "pointer to 4-element array of int", the type of the expression p[i] is "4-element array of int", thus we don't need to explicitly dereference p.

So, to sum up:

• Allocating and using a single element of type T:

      T *p = malloc( sizeof *p );
      *p = ...;
      free( p );

• Allocating and using a 1D array of T:

      T *p = malloc( N * sizeof *p );
      p[i] = ...;
      free( p );

• Allocating and using a 2D array of T:

      T (*p)[N] = malloc ( M * sizeof *p );
      p[i][j] = ...;
      free( p );

• Allocating and using a 3D array of T:

      T (*p)[M][N] = malloc (K * sizeof *p );
      p[i][j][k] = ...;
      free( p );

The pattern for higher-dimension arrays should be clear.