C dynamic allocation of an array under struct inside a function

You don't need a "double pointer"; you need a pointer to the object you want to modify. If you want the function to modify a pointer object, you need to pass a pointer to that object. If you want the function to modify a structure, you need to pass a pointer to that object.

And that's exactly what your code does. You want to modify main's tray, so you pass a pointer to main's tray. So your code works.

The following demonstrates this.

First, let's look at the code that doesn't work.

void fac( int *ac ) {
   ac = malloc( sizeof( int ) );
}

int main( void ) {
   int *a = NULL;
   fac( a );
   printf( "%p\n", (void *)a );   // XXX `a` isn't modified.
}

This code modifies ac, but it does not modify a. It does not achieve what we want it to achieve. To modify a, we would need to pass the address of a.

void fap( int **ap ) {
   *ap = malloc( sizeof( int ) );
}

int main( void ) {
   int *a = NULL;
   fap( &a );
   printf( "%p\n", (void *)a );   // XXX `s` isn't modified.
}

Here, rather than modifying the parameter, we modify *ap which is a. This code does achieve what we want it to achieve.

Now, let's introduce structs.

typedef struct { int *a } S;

void fsc( S sc ) {
   sc.a = malloc( sizeof( int ) );
}

int main( void ) {
   S s = { .a = NULL };
   fsc( s );
   printf( "%p\n", (void *)(s.a) );   // Ok. `s` is modified.
}

This code modifies sc, but it does not modify s. It does not achieve what we want it to achieve. To modify s, we would need to pass the address of s.

typedef struct { int *a } S;

void fsp( S *sp ) {
   sp->a = malloc( sizeof( int ) );   // `sp->a` means `(*sp).a`
}

int main( void ) {
   S s = { .a = NULL };
   fsp( &s );
   printf( "%p\n", (void *)(s.a) );   // Ok. `s` is modified.
}

Here, rather than modifying the parameter, we modify *sp which is s. This code does achieve what we want it to achieve.

Full demo:

#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

typedef struct { int *a; } S;

void fac( int *ac ) {
   ac = malloc( sizeof( int ) );
}

void fap( int **ap ) {
   *ap = malloc( sizeof( int ) );
}

void fsc( S sc ) {
   sc.a = malloc( sizeof( int ) );
}

void fsp( S *sp ) {
   sp->a = malloc( sizeof( int ) );   // `sp->a` means `(*sp).a`
}

int main( void ) {
   int *a = NULL;
   fac( a );
   printf( "%p\n", (void *)a );       // XXX `a` isn't modified.

   fap( &a );
   printf( "%p\n", (void *)a );       // Ok. `a` is modified.

   S s = { .a = NULL };
   fsc( s );
   printf( "%p\n", (void *)(s.a) );   // XXX `a` isn't modified.

   fsp( &s );
   printf( "%p\n", (void *)(s.a) );   // Ok. `s` is modified.
}

Warnings:

<source>: In function 'fac':
<source>:10:16: warning: parameter 'ac' set but not used [-Wunused-but-set-parameter]
   10 | void fac( int *ac ) {
      |           ~~~~~^~
<source>: In function 'fsc':
<source>:18:13: warning: parameter 'sc' set but not used [-Wunused-but-set-parameter]
   18 | void fsc( S sc ) {
      |           ~~^~

Output:

(nil)
0x158a2d0
(nil)
0x158a310

To change an object in a function you need to pass it by reference instead of passing by value.

In C passing by reference means passing an object indirectly through a pointer to it. Thus dereferencing the passed pointer you will get a direct access to the object pointed to by the pointer and can change it.

With a array (not inside a struct), even if I allocate arr inside a function with argument int *arr, it does not give main the allocated array, and it forces one to use double pointer there.

This means that the pointer is passed to the function by value. That is the function deals with its local variable (parameter) that was initialized by the value of the passed pointer. Changing the local variable does not changes the original pointer used as an argument of the function.

Consider a simple program

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

void f( int *p )
{
    p = malloc( sizeof( int ) );
}

int main( void )
{
    int *a = NULL;

    f( a );

    printf( "a == NULL is %s\n", a == NULL ? "true" : "false" );
}

You can imagine the function definition and its call the following way

f( a );

//...

void f( /* int *p */ )
{
    int *p = a;
    p = malloc( sizeof( int ) );
}

As you can see the function changes its local variable p that was initialized by the value of the pointer a passed to the function. The original pointer a stays unchanged.

If you want to change the pointer a declared in main within the function you need to pass it by reference. That is the program will look the following way

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

void f( int **p )
{
    *p = malloc( sizeof( int ) );
}

int main( void )
{
    int *a = NULL;

    f( &a );

    printf( "a == NULL is %s\n", a == NULL ? "true" : "false" );

    free( a );
}

Now dereferencing the pointer p within the function

*p = malloc( sizeof( int ) );

you get direct access to the original pointer a and thus can change it.

As for your first program then the pointer parr declared within the structure Tray

struct Tray {
  int *parr;
};

is passed to the function by reference through a pointer to an object of the structure type.

  struct Tray tray = {NULL}, *ptray;
  //...
  ptray = &tray;

  allocateTray(n, ptray);

That is dereferencing the pointer ptray within the function you get direct access to the original object of the structure type and can change (any) its data member.

Gerhardh's comment is correct: you are using a double pointer.

Consider:

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

struct Tray {
  int *parr;
};

void allocateTray(int n, struct Tray *tray) {
  tray->parr = calloc(n, sizeof(*tray->parr));

  for (int i = 0; i<n; i++) {
    tray->parr[i] = i+1;
  }
}

int main() {
  int *tray = NULL, **ptray;
  int         n;

  n = 5;

  ptray = &tray;

  allocateTray(n, (struct Tray*)ptray);

  for (int i = 0; i<n; i++) {
    printf("ptray[%d] = %d \n", i, (*ptray)[i]);
  }

  return 0;
}