Scanf and Dynamic memory allocation

int **elem;
elem = (int **)malloc(sizeof(int**) * numCol);

        for (i = 0; i < 2; i++)
		for (j = 0; j < numCol; j++)
		{
			scanf("%d", &elem[i][j]); //Shouldn't it give a value to the address pointed by 
                                     //a pointer to pointer to int?
			
		}

Why does this code give a segmentation fault error?(Segmentation fault: 11)
And this code works:

int **elem;
elem = (int **)malloc(sizeof(int**) * numCol);

        for (i = 0; i < 2; i++)
	    {
		elem[i] = (int *)malloc(numCol * sizeof(int));

		// Fill it with values

		for (j = 0; j < numCol; j++)
		{
			scanf("%d", &elem[i][j]);
		}

I'm confused. Besides that segmentation problem, doesn't int ** give a value of 4 ? Why not just use int.

The first code snippet segfaults because you haven’t allocated any memory for the array columns - each elem[i] doesn’t point to anything meaningful.

The general pattern for allocating "jagged" arrays like this is as follows:

/**
 * Allocate N "rows", which is actually an array of 
 * pointers to T
 */
T **arr = malloc( sizeof *arr * numRows ); // for any type T
if ( arr )
{
  /**
   * For each "row", allocate an array of T
   */
  for ( size_t i = 0; i < numRows; i++ )
  {
    arr[i] = malloc( sizeof *arr[i] * numCols );
    if ( arr[i] )
    {
      for ( size_t j = 0; j < numCols; j++ )
      {
        // initialize arr[i][j]
      }
    }
  }
}

Pictures may help.

First you start with the arr pointer:

     T **
     +–––+
arr: |   |
     +–––+

Then you allocate an array of pointer to T as your “rows” (to keep the picture a reasonable size, we’ll assume two rows and two columns):

     T **      T *
     +–––+     +–––+
arr: |   | ––> |   | arr[0]
     +–––+     +–––+
               |   | arr[1]
               +–––+

Finally you allocate arrays of T for each “row”:

     T **      T *               T
     +–––+     +–––+             +–––+
arr: |   | ––> |   | arr[0] –––> |   | arr[0][0]
     +–––+     +–––+             +–––+
               |   | arr[1] –+   |   | arr[0][1]
               +–––+         |   +–––+
                             |
                             |   +–––+
                             +-> |   | arr[1][0]
                                 +–––+
                                 |   | arr[1][1]
                                 +–––+

There’s no guarantee that sizeof (int **) is the same as sizeof (int *) or sizeof (int) (on x86_64, pointer sizes are typically 8 bytes).

Note that with this kind of piecemeal allocation, the rows are not going to be contiguous in memory - arr[1][0] does not immediately follow arr[0][1].

> I'm confused. Besides that segmentation problem, doesn't int ** give a
> value of 4? Why not just use int.

Not in all machine this is true, so it's correct to use the right type in the sizeof function to avoid error complicated to find out when program is running.

> Why does this code give a segmentation error?(Segmentation fault: 11)
> And this code works?

the first piece of code has an error in dynamic allocation of memory for the int** elem in fact you allocate only a row in the matrix.

In the second code you do the right initialization of the matrix. Pay attention in the second code your cycle is for i<2. This initialization is correct only if numCol is equal to 2.

A better code can be this :

int **elem;
elem = (int **)malloc(sizeof(int*) * numCol); //a correction in sizeof

        for (i = 0; i < numCol; i++) //cycle on numCol and not on 2
        {
            elem[i] = (int *)malloc(numCol * sizeof(int));

            // Fill it with values

            for (j = 0; j < numCol; j++)
            {
                scanf("%d", &elem[i][j]);
            }
 }