Courir à travers une structure et d'imprimer toutes les valeurs?

J'ai un pointeur vers une structure et je voudrais récupérer l'ensemble de ses membres par essai et erreur. Je suis en train de courir à travers la structure par incrémentation du pointeur par un et derefencing il. Elle doit retourner une valeur correcte de la structure (tous les i*sizeof(int) moment), mais il ne le fait pas.

Ce que je fais mal?

fn (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{

    /*
     assume that all struct members are int types

     typedef    struct 
     {
     mach_msg_bits_t    msgh_bits;
     mach_msg_size_t    msgh_size;
     mach_port_t        msgh_remote_port;
     mach_port_t        msgh_local_port;
     mach_msg_size_t    msgh_reserved;
     mach_msg_id_t      msgh_id;
     } mach_msg_header_t;

     size of the struct is 24.
     */

    printf("ID: %d \n",InHeadP->msgh_id); //prints 'ID: 1337'
    printf("Ptr: %p\n",InHeadP);

    for (int i = 0; i <= 24; i++)
    {
        int deref = *((int*)(InHeadP+i));
        printf("InHeadP[%d]=%d\n",i,deref);
            //no sign of 1337 anywhere

    }
}

P. S. je sais que je ne devrais pas faire ça, mais c'est uniquement pour des fins de test.

int *deref? N'avez-vous pas dire int deref?
Oui. int deref = *((int*)(InHeadP+i)). Changé.
"Il doit retourner une valeur correcte de la structure (chaque i*sizeof(int) temps) mais il ne fonctionne pas." -- Heu pourquoi devrait-il? ce n'est pas exactement la façon dont la mémoire est attribué.
Êtes-vous sûr que tous ces domaines sont en 32 bits? Si msgh_id est de 16 bits, vous ne verrez jamais un int c'est-à 1337. (Viens de voir votre assumer tous les types struct... commentaire. Encore, cela pourrait en fait être le cas?)
est-ce votre machine mot de 4 octets de long? en outre, ce qui ne sizeof (mach_msg_header_t) retour?
mach_msg_id_t est de int type. Pas sûr de la taille de celui-ci.
Taille de mach_msg_header_t est de 24.

InformationsquelleAutor Kristina Brooks | 2011-05-20

c struct structure

5

Parce que InHeadP est un mach_msg_header_t*, l'ajout d'un nombre entier, il sera effectivement ajouter ce nombre entier de fois sizeof(mach_msg_header_t), comme si vous étiez l'indexation d'un tableau de mach_msg_header_ts (et est en fait la façon dont la matrice de l'indexation des œuvres). Vous avez besoin de jeter InHeadP à un int* avant exécution de l'arithmétique, et même alors, la structure a six champs, i ne doit aller jusqu'à 6, pas 24.
- Comme nous l'avons tous convergent sur le problème presque simultanément! Je +1 pour être le premier, et parce qu'il est correct au sujet j'ai besoin d'aller jusqu'à 6, pas 24.
- *(((int*)(InHeadP))+i) travaillé! Merci!
- Très bonne question et très utile de répondre. Merci!
InformationsquelleAutor jwodder

Une méthode préférée pour itérer à travers une structure est de créer une fonction qui retourne la valeur ou de l'adresse du champ donné un indice. Notez que si l'ordre des membres de la struct changements, cette fonction doit changer:

int * Index_Of(unsigned int index, mach_msg_header_t * p_struct)
{
    switch (index)
    {
        case 0:  return (int *) &(p_struct->msgh_bits);
        case 1:  return (int *) &(p_struct->msgh_size);
        case 2:  return (int *) &(p_struct->msgh_remote_port);
        case 3:  return (int *) &(p_struct->msgh_local_port);
        case 4:  return (int *) &(p_struct->msgh_reserved);
        case 5:  return (int *) &(p_struct->msgh_id);
    }
    return 0;
}

Suffit de se rappeler que le traitement de la structure comme contiguë champs (membres) n'est pas conseillé, car le compilateur est autorisé à ajouter du rembourrage entre les membres de structure. Ainsi, une méthode pour accéder à la champs à l'exception de par son nom, est dangereux et va entraîner très difficile de bugs.

BTW, le traitement de chaque champ comme un int est également dangereux. Si l'un des types est changé en quelque chose d'autre, comme un double, votre code de casser. Le compilateur va pas de capture de l'erreur à cause de la coulée indique au compilateur que VOUS savez ce que vous faites.

Vous pourrait "tourner l'image autour de" et de mettre en œuvre un Visiteur modèle:

struct Visitor_Void
{
    void (*fn_msgh_bits)(mach_msg_bits_t);
    void (*fn_msgh_size)(mach_msg_size_t);
    void (*fn_msgh_remote_port)(mach_port_t);
    void (*fn_msgh_local_port)(mach_port_t);
    void (*fn_msgh_reserved)(mach_msg_size_t);
    void (*fn_msgh_id)(mach_msg_id_t);
};


void Visit_Members(mach_msg_header_t * p_header,
                   struct Visitor_Void * p_visitor)
{
    (p_visitor->fn_msgh_bits)(p_header->msgh_bits);
    (p_visitor->fn_msgh_size)(p_header->msgh_size);
    (p_visitor->fn_msgh_remote_port)(p_header->msgh_remote_port);
    (p_visitor->fn_msgh_local_port)(p_header->msgh_local_port);
    (p_visitor->fn_msgh_reserved)(p_header->msgh_reserved);
    (p_visitor->fn_msgh_id)(p_header->msgh_id);
    return;
}

+1 pour la mise en garde de ne pas faire d'hypothèses sur la disposition, et en particulier pour le modèle visiteur exemple.
Mon problème est que je ne connais pas la disposition de la structure. L'en-tête de message produit l'inconnu de mise en page.

InformationsquelleAutor Thomas Matthews

1

Non, vous ne devriez pas faire ça!

Ce qui est particulièrement mal ici
```
for (int i = 0; i <= 24; i++)
{
    int deref = *((int*)(InHeadP+i));
    printf("InHeadP[%d]=%d\n",i,deref);
}
```
est que l'impression de la première int de 24 différentes structures.
- Proposer une solution et je vais upvote
- Ma solution serait d'utiliser les 6 printf du langage et de ne pas s'embêter avec ce hack. 🙂
- Ici, il est 😛 (char limite)
InformationsquelleAutor Bo Persson
0

Lorsque vous appelez (int*)(InHeadP+i) vous faites de l'arithmétique des pointeurs sur mach_msg_header_t qui est de la taille 24. Donc, votre première itération est au début de la structure, et votre deuxième itération est juste après votre structure. Vous accédez à certains autres de la mémoire.

Essayer (((int*)InHeadP)+i).

InformationsquelleAutor David V
0

Attendez une seconde, ce qui est faux:
```
 int deref = *((int*)(InHeadP+i));
```
Vous voulez
```
int deref == *((int*)InHeadP+i)
```
Vous sauter 24 octets à chaque fois dans la boucle, plutôt que 4.

InformationsquelleAutor andrewdski

Vous devez vous connecter pour publier un commentaire.