Allocare memoria 2d array nella funzione C

Come allocare la memoria dynamic per l’array 2d in funzione? Ho provato in questo modo:

int main() { int m=4,n=3; int** arr; allocate_mem(&arr,n,m); } void allocate_mem(int*** arr,int n, int m) { *arr=(int**)malloc(n*sizeof(int*)); for(int i=0;i<n;i++) *arr[i]=(int*)malloc(m*sizeof(int)); } 

Ma non funziona.

upd: funzione corretta (risposta rapida)

 void allocate_mem(int*** arr, int n, int m) { *arr = (int**)malloc(n*sizeof(int*)); for(int i=0; i<n; i++) (*arr)[i] = (int*)malloc(m*sizeof(int)); } 

Il tuo codice è errato in *arr[i]=(int*)malloc(m*sizeof(int)); perché la precedenza dell’operatore [] è maggiore dell’operatore * deference: nell’espressione *arr[i] , viene dapprima arr[i] valutato poi * viene applicato. Quello di cui hai bisogno è il contrario (dereferenziamento arr , quindi applicare [] ).

Usa parentesi come questa: (*arr)[i] per sovrascrivere la precedenza degli operatori. Ora il tuo codice dovrebbe assomigliare a questo:

 void allocate_mem(int*** arr, int n, int m) { *arr = (int**)malloc(n*sizeof(int*)); for(int i=0; i 

Per capire meglio cosa succede nel codice sopra, leggi questa risposta .

È importante che deallocate la memoria allocata dynamicmente in modo esplicito una volta che avete finito di lavorarci. Per liberare la memoria allocata dalla funzione sopra, dovresti fare questo:

 void deallocate_mem(int*** arr, int n){ for (int i = 0; i < n; i++) free((*arr)[i]); free(*arr); } 

Inoltre, un modo migliore per creare un array 2D è allocare memoria contigua con una singola chiamata di funzione malloc() come di seguito:

 int* allocate_mem(int*** arr, int n, int m) { *arr = (int**)malloc(n * sizeof(int*)); int *arr_data = malloc( n * m * sizeof(int)); for(int i=0; i 

Per deallocare questa memoria:

 void deallocate_mem(int*** arr, int* arr_data){ free(arr_data); free(*arr); } 

Si noti che nella seconda tecnica, malloc viene chiamato solo due volte, e quindi nel codice deallocazione gratuito viene chiamato solo due volte invece di chiamarlo in un ciclo. Quindi questa tecnica dovrebbe essere migliore.

Se il tuo array non ha bisogno di essere ridimensionato (beh, puoi, ma sarà un po ‘più complicato), c’è un modo più semplice / più efficiente per build array 2D in C.

Dai un’occhiata a http://c-faq.com/aryptr/dynmuldimary.html .

Il secondo metodo (per l’array chiamato array2) è piuttosto semplice, meno doloroso (provare ad aggiungere i test per il valore di ritorno di mallocs) e in modo più efficiente.

L’ho appena confrontato, per un array 200×100, assegnato e deallocato 100000 volte:

  • Metodo 1: 1,8 s
  • Metodo 2: 47ms

E i dati nell’array saranno più contigui, il che potrebbe velocizzare le cose (potresti ottenere alcune tecniche più efficienti per copiare, ripristinare … un array assegnato in questo modo).

Considera questo: solo una singola allocazione

 int** allocate2D(int m, int n) { int **a = (int **)malloc(m * sizeof(int *) + (m * n * sizeof(int))); int *mem = (int *)(a + m); for(int i = 0; i < m; i++) { a[i] = mem + (i * n); } return a; } 

Liberare:

 free(a); 

Piuttosto, allocando la memoria in molti blocchi diversi, è ansible allocarla in un blocco di memoria consecutivo. Fare quanto segue:

 int** my2DAllocation(int rows,int columns) { int i; int header= rows *sizeof(int *); int data=rows*cols*sizeof(int); int ** rowptr=(int **)malloc(header+data); if(rowptr==NULL) { return NULL: } int * buf=(int*)(rowptr+rows); for(i=0;i 

Questo è un modo inutilmente complicato di allocare lo spazio per un array. Considera questo:

 int main(void) { size_t m = 4, n = 3; int (*2D_array)[m]; 2D_array = malloc(n * sizeof *2D_array); free(2D_array); return 0; } 

Ho provato il seguente codice per l’allocazione della memoria alla matrice bidimensionale.

  #include #include void main(void) { int **p;//double pointer holding a 2d array int i,j; for(i=0;i<3;i++) { p=(int**)(malloc(sizeof(int*)));//memory allocation for double pointer for(j=(3*i+1);j<(3*i+4);j++) { *p = (int*)(malloc(sizeof(int)));//memory allocation for pointer holding integer array **p = j; printf(" %d",**p);//print integers in a row printf("\n"); p++; } } } 

L'output del codice sopra riportato è: -

1 2 3

4 5 6

7 8 9

Per capire la matrice bidimensionale in termini di puntatori, dobbiamo capire come sarà allocata in memoria, dovrebbe essere qualcosa del genere: -

  1 2 3 1000 --> 100 104 108 4 5 6 1004 --> 200 204 208 7 8 9 1008 --> 300 304 308 

da quanto sopra, comprendiamo che, quando allociamo memoria al puntatore p che è un puntatore doppio, punta a una matrice di numeri interi, quindi in questo esempio vediamo che il 0x1000 è il puntatore p.

Questo puntatore punta al puntatore intero * p che è una matrice di numeri interi, quando la memoria è allocata all'interno del ciclo for interno, durante la prima iterazione il puntatore è 0x100 che punta al valore intero 1, quando assegniamo ** p = j. Analogamente punterà a 2 e 3 nelle prossime iterazioni nel ciclo.

Prima della successiva iterazione del ciclo esterno, il doppio puntatore viene incrementato, all'interno della successiva iterazione, come si vede in questo esempio, il puntatore si trova ora su 0x1004 e punta al puntatore intero che è una matrice di numeri interi 4,5,6 e in modo simile per le prossime iterazioni nel ciclo.

Array 2d array dinamico usando malloc:

 int row = 4; int column = 4; int val = 2; // memory allocation using malloc int **arrM = (int**)malloc (row*sizeof(int*)); for (int i=0;i
		      	

Prova il seguente codice:

  void allocate_mem(int*** arr,int n, int m) { *arr=(int**)malloc(n*sizeof(int*)); for(int i=0;i