Wie man ein zweidimensionales Array von Struct in C implementiert

Ich versuche gerade zu verstehen, wie man ein zweidimensionales Array von Struct in C implementiert. Mein Code stürzt die ganze Zeit ab und ich bin wirklich dabei, es enden zu lassen, wie alle meine Ansätze, die sich an C festhalten: Müll. Das habe ich bekommen:

typedef struct {
    int i;
} test;

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

Mein glorreicher Fehler:

Fehler: inkompatible Typen beim Zuweisen zum Typ ‘struct test *[20]’ vom Typ ‘struct test *’

Muss ich den Speicher für jede 2. Dimension separat zuweisen? Ich werde verrückt. Es sollte so einfach sein. Eines Tages werde ich eine Zeitmaschine bauen und ein paar C-Compiler-Floppies magnetisieren…

Das sollte reichen:

typedef struct {
    int i;
} test;

test t[20][20];

Dadurch wird ein zweidimensionales Array von deklariert test der Größe 20 x 20. Es besteht keine Notwendigkeit, malloc zu verwenden.

Wenn Sie Ihr Array dynamisch zuweisen möchten, können Sie dies tun:

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

test **t;

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

Andere Antworten zeigen, wie man es repariert, aber sie erklären nicht warum. Wie der Compiler angedeutet hat, ist der Typ von t in Ihrem ursprünglichen Beispiel ist tatsächlich test *[20] Deshalb Ihre Besetzung test * war nicht genug.

In C ist der Name eines Arrays T der Dimension N eigentlich vom Typ *T[dim0][dim1]...[dimN-1]. Spaß.

Aus meiner Beobachtung wissen Sie möglicherweise nicht genau, was Sie wollen, und verwechseln die Struktur- und Zeigerarithmetik. Bitte gehen Sie die folgenden 2 Möglichkeiten durch.

1) Ein zweidimensionales Array mit jedem Element hat einen Zeiger auf test. In diesem Fall die Speicher aller Zeiger auf tests sind bereits statisch zugeteilt. Aber die Erinnerung an das Wirkliche tests sind nicht bereit. In diesem Fall müssen Sie die ausfüllen test [i][j] Einer nach dem anderen.

Jedes von den test ist diskret im Speicher und Sie haben den Vorteil, sie individuell dynamisch zu erstellen oder zu zerstören.

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) Ein zweidimensionales Array mit jedem Element ist a test. In diesem Fall die Erinnerung an alle tests sind bereits zugeteilt. Auch die Erinnerung an das Wirkliche tests sind ohne zusätzliche Vorbereitung gebrauchsfertig.

Alle der tests liegen als großer Block im Speicher und sind immer da. Dies bedeutet, dass Sie möglicherweise einen Teil des Speichers verschwenden, wenn Sie nur alle benötigen tests zu bestimmten Spitzenzeiten und die meiste Zeit verwendet man nur wenige davon.

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

Solange die Größe Ihrer inneren Dimension konstant ist, können Sie außerdem eine variable Anzahl von Zählwerten dieser inneren Dimension zuweisen

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