¿Cómo devolver la matriz (matriz 2D) de la función? (C)

Creé una función que genera un tablero de bingo y quiero devolver el tablero de bingo.

como no esperaba, no funciona.

aquí está la función:

int** generateBoard() {
    int board[N][M], i, j , fillNum;
    Boolean exists = True;
    // initilize seed
    srand(time(NULL));
    // fill up..
    for(i = 0; i < N; ++i) {
        for(j = 0; j < M; ++j) {
            exists = True;
            while(exists) {
                fillNum = rand()%MAX_RANGE + 1; // limit up to MAX_RANGE
                if(beenAdded(board, fillNum) == Exist) {
                    continue;
                } else {
                    board[i][j] = fillNum;
                    exists = False;
                }
            }
        }
    }
    return board;
}

Tengo un error de compilación (la sublínea roja) en la línea “tablero de retorno”.

¿Hay alguna forma de devolver una matriz 2D? sin usando estructuras \ asignaciones dinámicas?

Estoy usando Microsoft Visual C++ Express 2010.

tu definiste board como una variable local: su memoria se desasigna a medida que la función queda fuera del alcance.

Puede declarar el tablero global, o puede crearlo dinámicamente así:

int **allocate_board(int Rows, int Cols)
{    
    // allocate Rows rows, each row is a pointer to int
    int **board = (int **)malloc(Rows * sizeof(int *)); 
    int row;

    // for each row allocate Cols ints
    for (row = 0; row < Rows; row++) {
        board[row] = (int *)malloc(Cols * sizeof(int));
    }

    return board;
}

Deberá liberar dinámicamente el tablero:

// you must supply the number of rows
void free_board(int **board, int Rows) 
{
    int row;

    // first free each row
    for (row = 0; row < Rows; row++) {
         free(board[row]);
    }

    // Eventually free the memory of the pointers to the rows
    free(board);
 }

Alguien tiene que poseer la memoria de ese tablero. algun lado, y lo que es más importante, esa propiedad debe extenderse a la persona que llama a esta función. Sin asignación dinámica, su única otra alternativa real es enviarlo a la función como parámetro de entrada/salida.

void generateBoard(size_t N, size_t M, int board[N][M])
{
    int i, j , fillNum;
    Boolean exists = True;
    // initilize seed
    srand(time(NULL));
    // fill up..
    for(i = 0; i < N; ++i) {
        for(j = 0; j < M; ++j) {
            exists = True;
            while(exists) {
                fillNum = rand()%MAX_RANGE + 1; // limit up to MAX_RANGE
                if(beenAdded(board, fillNum) == Exist) {
                    continue;
                } else {
                    board[i][j] = fillNum;
                    exists = False;
                }
            }
        }
    }
}

e invoque así desde su llamador:

int main()
{
    const size_t N = 10;
    const size_t M = 10;
    int board[N][M];

    generateBoard(N,M,board);

    ...
}

También consideraría reubicar el srand() llamar al código de inicio en main(). Idealmente, nunca debería estar en alguna función potencialmente repetible, y se debe garantizar que solo se ejecute una vez por ejecución del proceso. (nota: sinceramente no recuerdo si es una vez por hilo ejecución, pero en este punto de su curva de aprendizaje de codificación, supongo que los subprocesos múltiples aún no están en el radar).

Finalmente, su bucle de relleno aleatorio es innecesariamente repetitivo. Hay mejores alternativas que generan lo que aparentemente está tratando de hacer: crear una permutación aleatoria de un conjunto de números existente. Como está escrito, podría girar durante algún tiempo tratando de llenar esos últimos espacios, dependiendo de cuánto más grande MAX_RANGE se compara con (N*M).

int **setMatrix(int *row1, int *cols1) //return matrix
{
    int row, cols;
    int **matrix;
    printf("enter row:\n");
    scanf("%d",&row);
    printf("enter cols:\n");
    scanf("%d",&cols);
    
    
    matrix=(int **)calloc(cols ,sizeof(int*));
      for(int i=0;i<cols ;i++)
      {
          matrix[i]=(int *)calloc(row ,sizeof(int));
      }
    *row1=row;
    *cols1=cols;
    return matrix;

    


}


int main()
{
   int row ,cols;
   int **matrix;

   matrix=setMatrix(&row, &cols); //get the matrix back 
    
   return 0;
 }