Tengo la siguiente estructura:
typedef struct { int someArray[3][2]; int someVar; } myStruct; Si creo una matriz de esta estructura en mi main (como la siguiente), ¿cómo la inicializaría?
int main() { myStruct foo[5]; }
Quiero inicializar la matriz de estructura anterior de una manera similar a la de iniciar una matriz normal (ver más abajo):
int main() { int someArray[5] = {1,4,0,8,2}; }
Trabaja desde afuera hacia adentro. Sabes que tienes una serie de 5 cosas para inicializar:
mystruct foo[5] = { X, X, X, X, X };
donde X es un suplente para inicializadores de tipo mystruct . Así que ahora tenemos que averiguar cómo se ve cada X Cada instancia de mystruct tiene dos elementos, somearray y somevar , por lo que sabe que su inicializador para X se estructurará como
X = { Y, Z }
Sustituyendo de nuevo en la statement original, ahora obtenemos
mystruct foo[5] = { { Y, Z }, { Y, Z }, { Y, Z }, { Y, Z }, { Y, Z } };
Ahora tenemos que averiguar cómo se ve cada Y. Y corresponde a un inicializador para una matriz 3×2 de int . Nuevamente, podemos trabajar desde afuera hacia adentro. Usted tiene un inicializador para una matriz de 3 elementos:
Y = { A, A, A }
donde cada elemento de la matriz es una matriz de 2 elementos de int :
A = { I, I }
Substituyendo de nuevo en Y, obtenemos
Y = { { I, I }, { I, I }, { I, I } }
Sustituyendo eso de nuevo en X, obtenemos
X = { { { I, I }, { I, I }, { I, I } }, Z }
que ahora nos da
mystruct foo[5] = { { { { I, I }, { I, I }, { I, I } }, Z }, { { { I, I }, { I, I }, { I, I } }, Z }, { { { I, I }, { I, I }, { I, I } }, Z }, { { { I, I }, { I, I }, { I, I } }, Z }, { { { I, I }, { I, I }, { I, I } }, Z } };
Dado que Z es un complemento para un entero, no necesitamos dividirlo más. Simplemente reemplace I s y Z s con valores enteros reales, y listo:
mystruct foo[5] = { {{{101, 102}, {201, 202}, {301, 302}}, 41}, {{{111, 112}, {211, 212}, {311, 312}}, 42}, {{{121, 122}, {221, 222}, {321, 322}}, 43}, {{{131, 132}, {231, 232}, {331, 332}}, 44}, {{{141, 142}, {241, 242}, {341, 342}}, 45} };
Envuelva el inicializador para cada elemento de estructura de la matriz en un conjunto de llaves:
myStruct foo[5] = { { { { 11, 12 }, { 13, 14 }, { 55, 56 }, }, 70 }, { { { 21, 22 }, { 23, 24 }, { 45, 66 }, }, 71 }, { { { 31, 32 }, { 33, 34 }, { 35, 76 }, }, 72 }, { { { 41, 42 }, { 43, 44 }, { 25, 86 }, }, 73 }, { { { 51, 52 }, { 53, 54 }, { 15, 96 }, }, 74 }, };
Como eso:
int main() { // someArr initialization | someVar initialization mystruct foo[5] = { { { {1, 2}, {1,2}, {1, 2} }, 1 }, // foo[0] initialization //... }; }