Matrici multidimensionali allocate tramite calloc

Question

Ho una domanda su come viene allocata la memoria quando I calloc. Ho dato un'occhiata alla domanda this, ma non affronta come viene allocata la memoria nel caso di una matrice bidimensionale allocata dinamicamente.

Mi chiedevo se ci fosse una differenza nella rappresentazione della memoria tra i seguenti tre modi di allocare dinamicamente un array 2D.

Tipo 1:

double **array1; 
int ii; 

array1 = calloc(10, sizeof(double *)); 
for(ii = 0; ii < 10; ii++) { 
    array1[ii] = calloc(10, sizeof(double)); 
} 
// Then access array elements like array1[ii][jj] 

Tipo 2:

double **array1; 
int ii; 

array1 = calloc(10 * 10, sizeof(double *)); 
// Then access array elements like array1[ii + 10*jj] 

Tipo 3:

double **array1; 
int ii; 

array1 = malloc(10 * 10, sizeof(double *)); 
// Then access array elements like array1[ii + 10*jj] 

Da quello che ho capito di calloc e malloc, la differenza tra gli ultimi due è che calloc azzererà tutti gli elementi dell'array, mentre lo malloc non lo farà. Ma sono i primi due modi per definire l'array equivalente in memoria?

Answer 1

sono i primi due modi di definire la matrice equivalente in memoria?

Non proprio. Nel secondo tipo sono quasi certamente contigui, mentre nel primo tipo questo non è sicuro.

Tipo 1: in memoria rappresentazione sarà simile a questa:

  +---+---+---+---+---+---+---+---+---+---+ 
    double| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 
      +---+---+---+---+---+---+---+---+---+---+ 
      ^
      |------------------------------------          
       . . . . . . . . | // ten rows of doubles 
               - 
      +---+---+---+---+---+---+---+---+---+--|+ 
    double| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0|| 
      +---+---+---+---+---+---+---+---+---+--|+ 
      ^ . . .      - 
      | ^^^ . . . . . | 
      | | | | ^^^^^ | 
      +-|-+-|-+-|-+-|-+-|-+-|-+-|-+-|-+-|-+-|-+ 
array1[ii]| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | // each cell points to ten doubles 
      +---+---+---+---+---+---+---+---+---+---+ 
      ^
      | 
      | 
      +-|-+ 
    array1| | | 
      +---+ 

Tipo 2: in memoria rappresentazione sarà simile a questa:

  +---+---+---+---+---+---+---+---+---+---+  +---+ 
    double| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 
      +---+---+---+---+---+---+---+---+---+---+  +---+ 
      ^^^^^^^^^^  ^
      | | | | | | | | | |   | 
      | | | | | | | | | |   | 
      +-|-+-|-+-|-+-|-+-|-+-|-+-|-+-|-+-|-+-|-+  +-|-+ 
array1[ii]| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ... |99 | // each cell points to one double 
      +---+---+---+---+---+---+---+---+---+---+  +---+ 
      ^
      | 
      | 
      +-|-+ 
    array1| | | 
      +---+ 

Answer 2

Nel primo modo, si assegnano 10 puntatori al doppio e 100 al doppio. Nel secondo modo si assegnano 100 puntatori al doppio. L'altra differenza è che nel secondo modo si assegna un grande blocco di memoria, in modo che tutti gli elementi dell'array si trovino nello stesso blocco. Nel primo modo, ogni "riga" del tuo array si trova in un blocco diverso rispetto agli altri. Tuttavia, nel secondo modo, l'array dovrebbe essere un double * invece di un double **, perché in questo modo di allocazione, l'array contiene solo puntatori da raddoppiare, non double.

Answer 3

Sul caso 1, si effettua:

array1[0] -> [memory area of 10] 
array1[1] -> [memory area of 10] ... 
array1[N] -> [memory area of 10] ... 

Nota: non è possibile supporre che l'area di memoria è continuo, ci potrebbero essere vuoti.

Sul caso 2 si fanno:

array1 -> [memory area of 100] 

Il caso 3 è uguale al caso 2, ma la sua non inizializzare la memoria. Differenza tra i casi 1 e 2 & 3 è che nel primo caso si ha realmente una struttura di memoria 2D. Per esempio, se si desidera scambiare le righe 1 e 2, si può solo scambiare i puntatori:

help  = array1[1] 
array1[1] = array1[2] 
array1[2] = help 

Ma se si vuole fare lo stesso nel caso 2 & 3 è necessario fare vera memcpy. Cosa usare? Dipende da cosa stai facendo.

Il primo modo utilizza più memoria: se si dispone di array di 1000x10, la prima versione utilizzerà 1000 * 8 + 1000 * 10 * 8 (su sistema a 64 bit), mentre il 2 & 3 utilizzerà solo 1000 * 10 * 8.

Answer 4

Semplice esempio

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

int **d ; 
int sum(); 

//-----------------------------------------------    
int main(){ 

    d = (int **)calloc(3,sizeof(int)); 
    printf("\n%d",sum()); 

} 

//----------------------------------------------- 
int sum(){ 
int s = 0; 
for(int i = 0; i < 3; i++) 
    d[i] = (int *)calloc(3,sizeof(int)); 

for(int i = 0; i < 3; i++){ 
    for(int j = 0; j < 3; j++){ 
     d[i][j] = i+j; 
     s += d[i][j]; 
     printf("\n array[%d][%d]-> %d",i,j,d[i][j]); 
    } 
} 
return s; 
}