Itération sur même type struct membres en C

Est-il possible d'effectuer une itération d'une structure C, où tous les membres sont de même type, à l'aide d'un pointeur. Voici un exemple de code qui ne compile pas:

#include <stdio.h>
#include <stdlib.h>

typedef struct
{
    int mem1 ;
    int mem2 ;
    int mem3 ;
    int mem4 ;
} foo ;

void my_func( foo* data )
{
    int i ;
    int* tmp = data ; //This line is the problem

    for( i = 0; i < 4; ++i )
    {
        ++tmp ;
        printf( "%d\n", *tmp ) ;
    }
}

int main()
{
    foo my_foo ;
    //
    my_foo.mem1 = 0 ;
    my_foo.mem2 = 1 ;
    my_foo.mem3 = 2 ;
    my_foo.mem4 = 3 ;
    //
    my_func( &my_foo ) ;
    return 0 ;
}

Les membres de truc devrait être aligné dans la mémoire pour être l'un après l'autre, en supposant que votre compilateur/kernel n'essaie pas de fournir de protection de la pile de débordement de la mémoire tampon.

Donc ma question est:

Comment puis-je effectuer une itération sur les membres d'une structure C qui sont du même type.

Avez-vous essayé avec un plâtre, comme int * tmp = (int *)data'? Quel message d'erreur avez-vous l'obtenir?
David, avec la dernière mise à jour, le code fonctionne maintenant. Cette cession génère une fonte avertissement du compilateur. J'espérais qu'il y a un plus "élégant" de la solution.
Selon le langage C spécification, il n'est pas nécessaire que les champs de la structure sont les unes à côté des autres dans la mémoire; les compilateurs sont autorisés à insérer le remplissage entre les membres de champ. Si vous voulez itération, utiliser un tableau.

OriginalL'auteur Misha M | 2009-12-08

  1. 3

    Le plus simple serait de créer un syndicat, une partie qui contient chacun de ses membres individuellement et une partie qui contient un tableau. Je ne suis pas sûr si la plate-forme dépendant de rembourrage peut interférer avec l'alignement.

    Merci pour cette idée, complètement oublié l'aide d'une union ici. Je suis inquiet à propos de l'architecture des dépendances ici, bien que tous d'entre eux sont en 32 bits, donc, cela devrait être ok. Ma préoccupation dans la modification de la structure de la définition, serait l'impact sur le reste du code qui l'utilisent. Avoir à recompiler les bibliothèques et d'autres dépendances.
    Comme l'a souligné ci-dessous, alors que cela fonctionne avec de nombreux compilateurs et des plates-formes, il peut échouer sur les autres. Veuillez faire vos responsables d'une faveur et d'écrire des tests unitaires pour cette itération, lorsqu'elle tombe sur un étrange système un jour, il sera immédiatement évident.
    Je suis d'accord, à tout le moins, quelque chose comme assert((void*)&my_foo.s.mem4 == (void*)&my_foo.a.mem[3]);
    emk, déjà fait 🙂 Mark, merci pour l'exemple.

    OriginalL'auteur Mark Ransom

  2. 14

    La plupart des tentatives à l'aide d'une union avec un tableau de données sont sujettes à l'échec. Elles résistent à une chance décente de travail aussi longtemps que vous ne l'utilisez int s, mais pour d'autres, surtout les plus petits, les types, ils sont susceptibles de ne pas assez souvent car le compilateur ne peut (et surtout avec les petits types souvent) ajouter le remplissage entre les membres d'une struct, mais n'est pas autorisé à le faire avec des éléments d'un tableau).

    C ne, cependant, ont un offsetof() macro que vous pouvez utiliser. Il donne le décalage d'un élément dans une struct, de sorte que vous pouvez créer un tableau de décalages, puis (avec un peu de soin dans la coulée de), vous pouvez ajouter un décalage à l'adresse de la structure pour obtenir l'adresse du membre. Les soins dans le casting, c'est parce que le décalage en octets, de sorte que vous besoin de jeter l'adresse de l' struct à char *, puis ajouter le décalage, alors jetez le résultat à la catégorie de membre (int dans votre cas).

    +1 je pense que c'est le plus portable et de l'approche sécuritaire
    Jerry, merci. Je vais étudier offsetof(). Cela ne sonne comme la meilleure solution, puis à l'aide d'un syndicat.

    OriginalL'auteur Jerry Coffin

  3. 5

    De la langue du point de vue: vous ne pouvez pas. les données les membres de cette structure ne sont pas... euh.. "iteratible" en C, peu importe s'ils sont de même type ou de types différents.

    Utiliser un tableau au lieu d'un tas de membres indépendants.

    Une liste ou une carte fonctionne réellement mieux ici. Parfois, il n'est pas possible de changer l'architecture du code, donc on a à faire avec ce qui est là. Je ne suis pas d'accord avec vous au sujet de la langue du point de vue. C, le langage est défini, ne se soucient pas.
    La langue, tel que défini, ne soins si vous avez un tableau ou une structure. Vous pouvez parcourir un tableau, mais pas une struct.

    OriginalL'auteur AnT

  4. 2

    Vous pouvez également utiliser un sans nom de l'union/struct:

    struct foo {
    union {
        struct {
            int mem1;
            int mem2;
            int mem3;
            int mem4;
        };
        int elements[4];
    };
};

foo thefoo;
for (int i = 0; i < 4; ++i) {
    thefoo.elements[i] = i;
}

    Cela pourrait ne pas fonctionner sur certains compilateurs, int ce cas, vous aurez à explicitily nom de l'union et de la structure à l'intérieur de foo,

    OriginalL'auteur Andreas Brinck

  5. 1
        int* tmp = &data->mem1 ;  //explicitly get the address of the first int member

    Comme vous le dites, vous devez être prudent de l'alignement et de la mémoire d'autres problèmes d'implantation. Vous devriez être bien de le faire avec ints bien.

    Mais je m'interroge sur le degré de lisibilité de ce serait faire de votre code.

    Incidemment,

        tmp += ( i * sizeof(foo) ) ;

    Je ne pense pas qu'est-ce que vous pensez que cela fonctionne, mais je ne suis pas entièrement sûr de ce que vous voulez qu'il fasse. Utilisation ++tmp; si vous voulez étape à l'autre int membre de la même foo objet.

    Attention, cette approche est sensible à la structure de l'emballage. Je suis sûr que vous pouvez le faire fonctionner, mais je ne vous le conseille.
    J'ai essayé cette approche antérieure, mais l'obtention de l'adresse du premier membre n'a pas fonctionné non plus. L'adresse qu'il a continué de faire était mal.
    Dave, ++tmp ne fonctionnera pas pour toutes les architectures, d'où l'utilisation de sizeof. Si vous êtes de droite, qui ne fonctionne pas, soit, sizeof(toto) doit être sizeof(int). Grâce Fixe en question
    Je ne suis toujours pas sûr que c'est correct. Pourquoi i * sizeof(int)?
    encore une fois, pourquoi ++tmp ne pas fonctionner pour toutes les architectures? Je pense qu'il faut avancer tmp par la taille de la chose, c'points. Je crois que c'est la partie de la norme, si quelqu'un peut point à la partie de la norme qui définit ce, qui pourrait l'aider.

    OriginalL'auteur dave4420

  6. 1

    Voici une autre approche; je n'ai jamais eu de raison de le faire, mais il a l'avantage de ne pas coucher en place de la structure de la définition. Créer un tableau de pointeurs sur des membres qui vous intéresse, puis itérer sur ce tableau:

    typedef struct { int mem1; int mem2; int mem3, int mem4; } foo;
...
foo theStruct;
int *structMembers[4] = { &theStruct.mem1, &theStruct.mem2, 
                          &theStruct.mem3, &theStruct.mem4};
...
for (i = 0; i < 4; i++)
{
  printf("%d\n", *structMembers[i]);
}

    De cette façon, vous n'avez pas à vous soucier des problèmes d'alignement mordre, vous, et vous pouvez arbitrairement ordre de la façon dont vous souhaitez effectuer une itération sur les membres (par exemple, vous pouvez commander de sorte que le pied est "mem4, mem3, mem2, mem1").

    OriginalL'auteur John Bode

  7. 0

    Vous devriez être en mesure de lancer les foo pointeur vers un pointeur de int.

    Une solution plus propre serait de déclarer foo comme suit.

    typedef struct
{
    int fooints[ 4 ] ;
} foo ;

    Parcourir le tableau int.

    for ( int i = 0 ; i < 4 ; i++ )
{
    printf( "%d\n" , *( foo->fooints + i ) ) ;
}

    Vous pourriez aller pour créer des fonctions de membre de l'accès et/ou de manipuler le tableau int.

    OriginalL'auteur William Bell