void func (float *ptr);

func(&a[0][0]);

float *ptr=&a[0][0];
func(ptr);

void func (float **pFptr)
{ float *ptr=pFptr;

  ...

  *pFptr=ptr;
}

float *ptr=&a[0][0];
func(&ptr);

EXAMPLE 3 The following declarations demonstrate the compatibility rules for variably modified types.
   extern int n;
   extern int m;
   void fcompat(void)
   {
      int  a[n][6][m];
      int  (*p)[4][n+1];
      int  c[n][n][6][m];
      int  (*r)[n][n][n+1];
      p = a; // invalid: not compatible because  4 != 6
      r = c; // compatible, but defined behavior only if
             // n == 6 and m == n+1
   }

EXAMPLE 4 All declarations of variably modified (VM) types have to be at either block scope or
function prototype scope. Array objects declared with the static or extern storage-class specifier
cannot have a variable length array (VLA) type. However, an object declared with the static storageclass
specifier can have a VM type (that is, a pointer to a VLA type). Finally, all identifiers declared with a
VM type have to be ordinary identifiers and cannot, therefore, be members of structures or unions.

   extern int n;
   int A[n];             // invalid: file scope VLA
   extern int (*p2)[n];  // invalid: file scope VM
   int B[100];           // valid: file scope but not VM

   void fvla(int m, int C[m][m]); // valid: VLA with prototype scope

   void fvla(int m, int C[m][m]) // valid: adjusted to auto pointer to VLA
   {
      typedef int VLA[m][m];     // valid: block scope typedef VLA

      struct tag {
         int (*y)[n];     // invalid: y not ordinary identifier
         int z[n];        // invalid: z not ordinary identifier
      };
      int D[m];                  // valid: auto VLA
      static int E[m];           // invalid: static block scope VLA
      extern int F[m];           // invalid: F has linkage and is VLA
      int (*s)[m];               // valid: auto pointer to VLA
      extern int (*r)[m];        // invalid: r has linkage and points to VLA
      static int (*q)[m] = &B;   // valid: q is a static block pointer to VLA
   }

float func( int i; int j; float a[i][j] )
{
   float s = 0.0;
   for( int ii = 0; ii < i; ii++)
      for( int jj = 0; jj < j; jj++)
         s += a[ii][jj];

   return s;
}

float m[5][5];
float mm[25][3];

func( 5, 5, m );
func( sizeof(mm)/sizeof(mm[0]), sizeof(mm[0])/sizeof(mm[0][0]), mm );

void main()
{
    volatile float Tmp1 = 1.2345;
    volatile float Tmp2 = 678.9;
    volatile Tmp3 = Tmp1 * Tmp2;
   // аналогично для целых
   ........
}