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

4 minutos de lectura

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.

  • use malloc para la asignación de matriz 2D de la placa,

    – Adel Ahmed

    30 de diciembre de 2012 a las 6:29

  • No puedo , esto es tarea .. si pudiera , lo haría ..

    – Billie

    30 de diciembre de 2012 a las 6:31

  • Más te vale. En este momento, está devolviendo una variable local que ya no es válida al salir del alcance de la función. Su comportamiento indefinido. ¿Es aceptable el parámetro de entrada y salida?

    – WhozCraig

    30 de diciembre de 2012 a las 6:32


  • No, porque aún no aprendimos punteros. (aunque lo hice..). de todos modos, hágalo en función no requerida. solo lo creo mas claro..

    – Billie

    30 de diciembre de 2012 a las 6:36

  • ¿Esta función solo se llama una vez? ¿Aprendiste el static palabra clave todavía?

    – mpontillo

    30 de diciembre de 2012 a las 6:54

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);
 }

avatar de usuario
QuiénesCraig

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).

avatar de usuario
Asher Abecassis

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;
 } 

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad