C - deklariert int array innerhalb der Struktur

Question

In C habe ich die unten gezeigte Struktur definiert und möchte sie inline initialisieren. (Weder die Felder innerhalb der Struktur, noch das Array foos wird nach der Initialisierung ändern). Der Code im ersten Block funktioniert einwandfrei.

struct Foo { 
    int bar; 
    int *some_array; 
}; 
typedef struct Foo Foo; 

int tmp[] = {11, 22, 33}; 
struct Foo foos[] = { {123, tmp} }; 

Allerdings brauche ich nicht wirklich das tmp-Feld. In der Tat, es wird nur meinen Code überfluten (dieses Beispiel ist etwas vereinfacht). Stattdessen möchte ich stattdessen die Werte some-array in der Deklaration für foos deklarieren. Ich kann jedoch nicht die richtige Syntax bekommen. Vielleicht sollte das Feld Some-Array anders definiert werden? Hier

int tmp[] = {11, 22, 33}; 
struct Foo foos[] = { 
    {123, tmp}, // works 
    {222, {11, 22, 33}}, // doesn't compile 
    {222, new int[]{11, 22, 33}}, // doesn't compile 
    {222, (int*){11, 22, 33}}, // doesn't compile 
    {222, (int[]){11, 22, 33}}, // compiles, wrong values in array 
}; 

Answer 1

int *some_array; 

, some_array ist eigentlich ein Zeiger, kein Array. Sie können es wie folgt definieren:

struct Foo { 
    int bar; 
    int some_array[3]; 
}; 

Eine weitere Sache, der ganze Sinn der typedef struct Foo Foo; ist Foo statt struct Foo zu verwenden. Und Sie können typedef wie folgt verwenden:

typedef struct Foo { 
    int bar; 
    int some_array[3]; 
} Foo; 

Answer 2

Erstens gibt es 2 Möglichkeiten:

• Sie wissen, dass Arrays Größe
• Sie wissen nicht, dass Größe.

Im ersten Fall ist es ein statisches Programmierproblem, und es ist nicht kompliziert:

#define Array_Size 3 

struct Foo { 
    int bar; 
    int some_array[Array_Size]; 
}; 

können Sie diese Syntax verwenden das Array zu füllen:

struct Foo foo; 
foo.some_array[0] = 12; 
foo.some_array[1] = 23; 
foo.some_array[2] = 46; 

Wenn Sie nicht kennen die Größe des Arrays, es ist ein dynamisches Programmierproblem. Sie müssen die Größe fragen.

struct Foo { 

    int bar; 
    int array_size; 
    int* some_array; 
}; 


struct Foo foo; 
printf("What's the array's size? "); 
scanf("%d", &foo.array_size); 
//then you have to allocate memory for that, using <stdlib.h> 

foo.some_array = (int*)malloc(sizeof(int) * foo.array_size); 
//now you can fill the array with the same syntax as before. 
//when you no longer need to use the array you have to free the 
//allocated memory block. 

free(foo.some_array); 
foo.some_array = 0;  //optional 

Zweitens ist typedef nützlich, so das, wenn Sie schreiben:

typedef struct Foo { 
    ... 
} Foo; 

es bedeutet, dass Sie die "struct Foo" Wörter mit diesem ersetzen: "Foo". So ist die Syntax wird dies:

Foo foo; //instead of "struct Foo foo; 

Beifall.

Answer 3

Meine Antwort für den folgenden Code-Abschnitt ist: -

int tmp[] = {11, 22, 33}; 
struct Foo foos[] = { 
    {123, tmp}, // works 
    {222, {11, 22, 33}}, // doesn't compile 
    {222, new int[]{11, 22, 33}}, // doesn't compile 
    {222, (int*){11, 22, 33}}, // doesn't compile 
    {222, (int[]){11, 22, 33}}, // compiles, wrong values in array 
}; 

Alle oben genannten Zusammenstellung Ausgaben ist aufgrund es nicht kompatibel mit den ANSI-Standards ist, ist das Aggregat ‚foos‘ mit subaggregates einige davon geklammert, während andere nicht sind. Also, wenn Sie die internen Klammern entfernen, um das Array 'tmp' darzustellen, würde es ohne Fehler kompilieren. Für z.

struct Foo foos[] = { 
    {123, tmp}, // works 
    {222, 11,22,33 }, // would compile perfectly. 
}