Come implementare una matrice bidimensionale di struct in C

Question

Attualmente sto cercando di capire come implementare una matrice bidimensionale di struct in C. Il mio codice si blocca in continuazione e sto davvero per lasciarlo finisce come se tutti i miei approcci diventassero saldi in C: spazzatura. Questo è quello che ho ottenuto:

typedef struct { 
    int i; 
} test; 

test* t[20][20]; 
*t = (test*) malloc(sizeof(test) * 20 * 20); 

mio errore gloriosa:

error: incompatible types when assigning to type ‘struct test *[20]’ from type ‘struct test *’

Devo allocare la memoria separatamente per ogni 2 ° dimensione? Sto diventando matto. Dovrebbe essere così semplice. Un giorno mi costruirò una macchina del tempo e magnetizzare compilatore C-floppy ...

Answer 1

Questo dovrebbe essere sufficiente:

typedef struct { 
    int i; 
} test; 

test t[20][20]; 

Che vi dichiarare una matrice a 2 dimensioni di test di taglia 20 x 20. Non è necessario usare malloc.

Se si desidera allocare dinamicamente l'array si può fare questo:

// in a function of course 
test **t = (test **)malloc(20 * sizeof(test *)); 
for (i = 0; i < 20; ++i) 
    t[i] = (test *)malloc(20 * sizeof(test)); 

Answer 2

test **t; 

t = (test **)malloc(sizeof(test *) * 20); 
for (i = 0; i < 20; i++) { 
    t[i] = (test *)malloc(sizeof(test) * 20); 
} 

Answer 3

altre risposte mostrano come risolvere il problema, ma non spiegano il motivo. Come suggerito dal compilatore, il tipo di t nell'esempio originale è in realtà test *[20] ed è per questo che il cast a test * non è stato sufficiente.

In C, il nome di un array T di dimensione N è in realtà di tipo *T[dim0][dim1]...[dimN-1]. Divertimento.

Answer 4

Dalla mia osservazione, potresti non sapere esattamente cosa vuoi e confondere sulla struttura e l'aritmetica del puntatore. Si prega di passare attraverso le seguenti 2 possibilità.

1) Un array bidimensionale con ciascun elemento ha un puntatore a test. In questo caso la memoria di tutti i puntatori a test s è già statica allocata. Ma la memoria del reale test s non è pronta. In questo caso è necessario compilare uno per uno il numero test [i][j].

Ciascuno del test è discreto nella memoria e si ha il vantaggio di crearli o distruggerli singolarmente in modo dinamico.

typedef struct { 
    int i; 
} test; 

test* t[20][20]; 
/* or instead of statically allocated the memory of all the pointers to tests 
    you can do the following to dynamically allocate the memory 
    test ***t; 
    t = (test***)malloc(sizeof(test *) * 20 * 20); 
*/ 

for (int i=0; i < 20; i++){ 
    for (int j=0; j < 20; j++){ 
     t[i][j] = malloc(sizeof(test)); 
    } 
} 

2) Una matrice bidimensionale con ciascun elemento è un test. In questo caso la memoria di tutti gli test s è già allocata. Inoltre, la memoria reale test s è pronta per l'uso senza preparazione extra.

Tutte le test s sono continue nella memoria, come un grande blocco ed è sempre presente. Ciò significa che si può perdere un pezzo di memoria se solo avete bisogno di tutte test s ad una certa ora di punta e il più delle volte si usa solo alcuni di loro.

typedef struct { 
    int i; 
} test; 

test t[20][20]; 
/* or instead of statically allocated the memory of all tests 
    you can do the following to dynamically allocate the memory 
    test **t; 
    t = (test**)malloc(sizeof(test) * 20 * 20); 
*/ 

Answer 5

Inoltre, a patto che il formato di dimensione interna è costante, è possibile allocare un numero variabile di conti di quella dimensione interiore

int n = ...; 
test (*t)[20] = malloc(sizeof (*t) * n); 
t[0 .. (n-1)][0 .. 19] = ...;