Eu consegui trabalhar com Matrizes de comprimento variável emC e agora tenho o seguinte:

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

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

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))[3]{
    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;
}

Resultado:

Give the ROW: 2
Give the COL: 5
0 1 2 3 4 5 6 7 8 9

Agora isso:

int (*foo(size_t row, size_t col))[3]{ /* code */ }

significa que, se eu entendi direito, que declara foo como uma função com dois parâmetros (size_t linha, size_t col) que retorna um ponteiro para uma matriz 3 de int.

Não sou totalmente capaz de entender esse tipo de função e agora é mais complicado trabalhar com matrizes de comprimento variável quando o tamanho é conhecido apenas em tempo de execução, mas acho isso uma coisa boa. Estou trabalhando apenas comC11 padrão.

De qualquer maneira aquiint (*foo(size_t row, size_t col))[3] Eu tenho isso [3], que não sou claro sobre como funciona e como posso torná-lo possível no tempo de execução (é claro, apenas se possível), algo comoint (*foo(size_t row, size_t col))[SIZE].

Eu li alguns livros sobreC, mas não há exatamente explicações sobre essa situação e o Google também não ajuda, por isso tenho duas perguntas:

1) Isso é possívelint (*foo(size_t row, size_t col))[SIZE] , onde SIZE deve ser o parâmetro? Ou devo declarar esta função de outra maneira?

2) é este o caminho certo para o que tentei aqui ou existe outra alternativa?

Eu só estou tentando retornar um ponteiro para uma matriz onde o tamanho é conhecido em tempo de execução e não em tempo de compilação. A chamada demalloc efree acontece apenas uma vez e esta é uma boa abordagem, porque sempre quemalloc é chamado, nosso programa perturba o kernel para alocar memória e marcar a página como gravável. Portanto, esse método tem menos sobrecargakernel. Pode ser escrito em ummalloc trabalhando com VLA's

EDITAR:

@ChronoKitsune disse que eu deveria usar / tentar[] (matriz de tamanho não especificado); nesse caso, a função se tornará assim:

int (*foo(size_t row, size_t col))[]{ /* code */ }

É isso que eu devo usar?