Question about the difference between Integer triple pointer and float triple pointer

Question

I'm doing a project for school and they force us to use a type float triple pointer in a function that multiply two matrices, and for the last day i can't figure out why when I'm using int triple pointer I get the numbers needed but when I'm using float I get zeros. I wrote something simple just for example for the problem. Thank you !!

    int ***ptr3;
    int Matrix[3][3] = { {1,2,3},{4,5,6},{7,8,9} };
    int i;

    ptr3 = malloc(sizeof(int));
    ptr3 = Matrix;
    for (i = 0; i < 9; i++) {printf_s("%d ", ptr3[i]);}


    printf_s("\n");


    float ***ptr3_f;
    float Matrix_f[3][3] = { {1,2,3},{4,5,6},{7,8,9} };

    ptr3_f = malloc(sizeof(float));
    ptr3_f = Matrix_f;
    for (i = 0; i < 9; i++) {printf_s("%.1f ", ptr3_f[i]);}

enter image description here

Answer 1

There is a whole lot of misconceptions here and your teacher does unfortunately not seem to know C very well. You simply can't use a type*** and it doesn't make any sense to use either.

• A pointer of the type type*** cannot point at a 3D array of type. Nor can it point at a 2D array. It cannot point at any array type at all.

  Sometimes when using dynamic memory allocation, we allocate an array of type*, each pointing at the first item in an array. A type** can then be used to point at the first type* element, to emulate the syntax of a 2D array with [i][j] access.

  This does however not magically make the array of type* an array type[] at the same time. Nor does it magically make type** an array type[][]. If someone taught you that, they are confused.

  Most of the time, we should not use type** to emulate a 2D array in the first place, because doing so is horribly inefficient. See Correctly allocating multi-dimensional arrays.

• Thus when you attempt ptr3 = Matrix;, you get a C language constraint violation error by the compiler. Some lax compilers "only" give you a warning, but that doesn't make the code valid C. The type*** cannot be used to point at a 3D array, period.

  If you somehow got the correct output in some scenario, that's by luck, since the behavior of your code isn't well-defined. On some system, int happened to have the same size as the pointer or such.

• ptr3 = malloc(sizeof(int)); ptr3 = ... is senseless, since all that you achieve with the malloc is a memory leak. Because the first thing you do is to overwrite the pointer address to the data you just allocated. I'm not sure why you want to allocate a single int to begin with.

Getting rid of all misconceptions, you can perhaps salvage the program in the following manner:

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

int main (void)
{

  int (*iptr)[3];
  int imatrix[3][3] = { {1,2,3},{4,5,6},{7,8,9} };

  iptr = imatrix;
  for (int i=0; i<3; i++)
  { 
    for (int j=0; j<3; j++)
    {
      printf_s("%d ", iptr[i][j]);
    }
    printf("\n");
  }

  printf("\n");

  float (*fptr)[3];
  float fmatrix [3][3] = { {1.0f,2.0f,3.0f},{4.0f,5.0f,6.0f},{7.0f,8.0f,9.0f} };

  fptr = fmatrix;
  for (int i=0; i<3; i++)
  { 
    for (int j=0; j<3; j++)
    {
      printf_s("%.1f ", fptr[i][j]);
    }
    printf("\n");
  }
}

Answer 2

Did you see the warning when you compile your code:

warning: assignment from incompatible pointer type [-Wincompatible-pointer-types]

warning: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘int **’ [-Wformat=]
assignment from incompatible pointer type [-Wincompatible-pointer-types]

warning: format ‘%f’ expects argument of type ‘double’, but argument 2 has type ‘float **’ [-Wformat=]

You can do something like:

ptr3 = malloc(sizeof(int**)); // allocate the memory for storing one double pointer
*ptr3 = malloc(sizeof(int*)); // allocate the memory for storing one single pointer
**ptr3 = Matrix[0]; // point to first row of the matrix

// it's similar to float pointer type
ptr3_f = malloc(sizeof(float**)); 
*ptr3_f = malloc(sizeof(float*)); 
**ptr3_f = Matrix_f[0];

Then when you want to print:

for (i = 0; i < 9; i++) {printf("%d ", (**ptr3)[i]);}
for (i = 0; i < 9; i++) {printf("%.1f ", (**ptr3_f)[i]);}

Answer 3

You don't need triple pointer for such arrays.

With:

#include <stdio.h>

#include <stdlib.h>

int main()
{

    int *ptr3_i;
    int Matrix[3][3] = { {1,2,3},{4,5,6},{7,8,9} };

    float *ptr3_f;
    float Matrix_f[3][3] = { {1,2,3},{4,5,6},{7,8,9} };

    int i;

    ptr3_i = (int *)Matrix;
    printf("ptr3_i:");
    for (i = 0; i < 9; i++) 
        printf("%d ", ptr3_i[i]);
    printf("\n");

    ptr3_f = (float *)Matrix_f;
    printf("ptr3_f:");
    for (i = 0; i < 9; i++) 
        printf("%.1f ", ptr3_f[i]);
    printf("\n");

    return 0;
}

I get:

ptr3_i:1 2 3 4 5 6 7 8 9 
ptr3_f:1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0