Come restituire la matrice (array 2D) dalla funzione? (C)

Ho creato una funzione che genera una bingo e voglio restituire la bingo.

come non mi aspettavo, non funziona.

ecco la funzione:

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

Ho un errore di compilazione (il rosso in sublocazione) nella riga “ritorno a bordo”.

c’è modo di restituire un array 2D senza usare structs \ dynamic allocation?

Sto usando Microsoft Visual C ++ Express 2010.

Qualcuno deve possedere la memoria di quella scheda da qualche parte e, cosa più importante, che la proprietà deve estendersi al chiamante di questa funzione. Senza l’allocazione dynamic, l’unica altra vera alternativa è quella di inviarlo nella funzione come in un parametro in / out.

 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 invoca in questo modo dal tuo chiamante:

 int main() { const size_t N = 10; const size_t M = 10; int board[N][M]; generateBoard(N,M,board); ... } 

Vorrei anche prendere in considerazione il riposizionamento della chiamata srand() al codice di avvio in main() . Idealmente non dovrebbe mai essere in qualche funzione potenzialmente richiudibile, e dovrebbe essere garantito che venga eseguito solo una volta per l'esecuzione del processo. (nota: onestamente non riesco a ricordare se è una volta per l'esecuzione del thread , ma a questo punto della curva di apprendimento del codice credo che il multi-threading non sia ancora nel radar).

Infine, il tuo ciclo di riempimento casuale è inutilmente ripetitivo. Ci sono alternative migliori che generano ciò che stai apparentemente cercando di fare: creare una permutazione casuale di un insieme esistente di numeri. Come scritto potresti girare per un po 'di tempo cercando di riempire gli ultimi slot, a seconda di quanto MAX_RANGE è più grande rispetto a (N*M) .

La board definita come variabile locale: la sua memoria viene gestita poiché la funzione non rientra nell’ambito.

Puoi dichiarare la bacheca globale, oppure puoi crearla dynamicmente in questo modo:

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

Dovrai liberare dynamicmente la scheda:

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