Functions for dynamically allocating an array in C -- Any difference between the two?

Question

Suppose you have a function in C that accepts the dimensions for a 2d array (for simplicity's sake, say for a square nxn array), dynamically allocates the array, then returns it.

I'm aware allocating memory here might be considered somewhat bad practice to begin with, since it will need to be freed elsewhere, but suppose that's not a huge issue. I'm wondering if there's any advantages/disadvantages associated with these two variations of said function:

Variation 1 - Locally define int** variable in function, allocate/return array:

int **create_array(int n) {
    // define array pointer, allocate array...
    int **a_ = (int**)calloc(n,sizeof(int*));
    for (int i = 0; i < n; i++) 
        a_[i] = (int*)calloc(n,sizeof(int));
    return a_;
}

int main() {
    int n = 3;
    int **array2d = create_array(n)
    printf("First element: %d%c",array2d[0][0],'\n');
    // do stuff... etc...
}

Variation 2 - Add in-out int** parameter to function, allocate/return array:

int **create_array_2(int **a_, int n) {
    // allocate array...
    a_ = (int**)calloc(n,sizeof(int*));
    for (int i = 0; i < n; i++) 
        a_[i] = (int*)calloc(n,sizeof(int));
    return a_;
}

int main() {
    int n = 3;
    int **array2d;
    array2d = create_array_2(array2d,n);
    printf("First element: %d%c",array2d[0][0],'\n');
    // do other stuff... etc...
}

Obviously they return the same result and achieve the same task, but is one considered to be safer/more efficient/better practice than the other? In my opinion the 2nd variation just makes things look a bit redundant, but I'm curious if there's any real differences between the two and what happens on the stack/heap when they're called. Hopefully this isn't a dumb question; it's just something I've been curious about. If anyone has insight to share, I'd appreciate it.

Answer 1

I'll probably try to avoid calling malloc and free to many times so this kind of approach is what I'll do:

Example 1:

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

int *foo(size_t row, size_t col);

int main(void){
    int *arr;
    unsigned int row, col, k;

    printf("Give the ROW: ");
    if ( scanf("%u",&row) != 1){
        printf("Error, scanf ROW\n");
        exit(1);
    }

    printf("Give the COL: ");
    if ( scanf("%u",&col) != 1){
        printf("Error, scanf COL\n");
        exit(2);
    }

    arr = foo(row, col);
    for (k = 0 ; k < (row * col) ; k++){
        printf("%d ",arr[k]);
    }

    free(arr);
}

int *foo(size_t row, size_t col){
    unsigned int i, j;
    int *arr = malloc(sizeof *arr * row * col);
    int l = 0;

    if(arr == NULL){
        printf("Error, malloc\n");
        exit(3);
    }

    for ( i = 0; i < row ; i++){
        for ( j = 0 ; j < col ; j++){
            arr[i * col + j] = l;
            l++;
        }
    }

    return arr;
}

Output:

Give the ROW: 6
Give the COL: 3
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Example 2 (if you are working with the standard C):

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

int (*foo(size_t row, size_t col))[];

int main(void){
    size_t row, col;


    printf("Give the ROW: ");
    if ( scanf("%zu",&row) != 1){
        printf("Error, scanf ROW\n");
        exit(1);
    }

    printf("Give the COL: ");
    if ( scanf("%zu",&col) != 1){
        printf("Error, scanf COL\n");
        exit(2);
    }

    int (*arr)[col] = foo(row, col);

    for ( size_t i = 0; i < row; i++){
        for( size_t j = 0; j < col; j++){
            printf("%d ",*(*(arr+i)+j));
        }
    }

    free(arr);
}

int (*foo(size_t row, size_t col))[]{
    int (*arr)[col] = malloc(row * col * sizeof(int));
    int l=0;

    if (arr == NULL){
        printf("Error, malloc\n");
        exit(3);
    }

    for ( size_t i = 0; i < row; i++){
        for( size_t j = 0; j < col; j++){
            *(*(arr+i)+j) = l;
            l++;
        }
    }

    return arr;
}

Output:

Give the ROW: 6
Give the COL: 3
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

The whole point here is that the call of malloc and free in both examples takes place only one time

Answer 2

IMO, of the two you are better off simply returning the value. This way there's a pure and solid wall between you and the caller.

"Give me some stuff!"

"Okay, here's some stuff."

On the other hand, for actually allocating an array of fixed size, why bother with pointers? Why not declare your return type so as to be castable to a sized array?

int (*p2a)[15] = (int(*)[15])create_array_2(15, 15);

Then you would calloc(15*15,sizeof(int)) and be done.