Accéder à array en tant que struct *

Je pense que cela devrait fonctionner, mais il vaut mieux vérifier les questions. Il comstack et fonctionne bien sur ma machine.

Est-ce que cela garantit de faire ce que j’attends (c’est-à-dire me permettre d’accéder aux premiers éléments du tableau avec une garantie que la disposition, l’alignement, le remplissage, etc. de la structure est identique à celui du tableau)?

struct thingStruct { int a; int b; int c; }; void f() { int thingsArray[5]; struct thingStruct *thingsStruct = (struct thingStruct *)&thingsArray[0]; thingsArray[0] = 100; thingsArray[1] = 200; thingsArray[2] = 300; printf("%d", thingsStruct->a); printf("%d", thingsStruct->b); printf("%d", thingsStruct->c); } 

EDIT: Pourquoi diable voudrais-je faire quelque chose comme ça? J’ai un tableau que je mappe sur un fichier. Je traite la première partie du tableau comme un “en-tête”, qui stocke diverses informations sur le tableau, et le rest, je le traite comme un tableau normal. Si je pointe la structure au début du tableau, je peux accéder aux éléments de données d’en-tête en tant que membres de structure, ce qui est plus lisible. Tous les membres de la structure seraient du même type que le tableau.

Bien que cela ait souvent été fait, vous ne pouvez pas (en d’autres termes, c’est-à-dire que ce n’est pas légal, standard C) présumer de la présentation binary d’une structure, car il peut y avoir un remplissage entre les champs.

Ceci est expliqué dans la FAQ comp.lang.c: http://c-faq.com/struct/padding.htmls

Bien que cela fonctionne probablement dans la plupart des endroits, cela rest un peu incertain. Si vous voulez donner des noms symboliques à des parties de l’en-tête, pourquoi ne pas simplement faire:

 enum { HEADER_A, HEADER_B, HEADER_C }; /* ... */. printf("%d", thingsArray[HEADER_A]); printf("%d", thingsArray[HEADER_B]); printf("%d", thingsArray[HEADER_C]); 

Comme Evan a commenté la question, cela fonctionnera probablement dans la plupart des cas (encore une fois, mieux si vous utilisez #pragma pack pour vous assurer qu’il n’y a pas de remplissage), en supposant que tous les types de votre structure soient du même type que votre tableau. Compte tenu des règles de C, c’est légal.

Ma question est “pourquoi?” Ce n’est pas une chose particulièrement sûre à faire. Si un flotteur est jeté au milieu de la structure, tout s’écroule. Pourquoi ne pas simplement utiliser la structure directement? Ce n’est vraiment pas une technique que je recommanderais dans la plupart des cas.

Une autre solution pour représenter un en-tête et le rest des données de fichier utilise une structure comme celle-ci:

 struct header { long headerData1; int headerData2; int headerData3; int fileData[ 1 ]; // <- data begin here }; 

Ensuite, vous allouez le bloc de mémoire avec le contenu du fichier et le struct header *myFileHeader (ou struct header *myFileHeader le bloc de mémoire sur un fichier) et accédez à toutes vos données de fichier avec

 myFileHeader->fileData[ position ] 

pour grande position arbitraire. Le langage n'impose aucune ressortingction sur la valeur d'index, il vous incombe donc de conserver votre position importante arbitraire dans la taille réelle du bloc de mémoire que vous avez alloué (ou la taille du fichier mappé).

Une autre remarque importante: en dehors de la désactivation du remplissage des membres de la structure, qui a déjà été décrit par d’autres, vous devez choisir avec soin les types de données pour les membres d’en-tête, afin qu’ils s'adaptent à la présentation réelle des données du fichier malgré le compilateur utilisé (par exemple, ne changera pas de 32 à 64 bits ...)