Comment puis-je obtenir/définir une struct membre par compensation

Ignorant rembourrage/problèmes d'alignement et compte tenu de la structure suivante, quelle est la meilleure façon d'obtenir et de définir la valeur de member_b sans utiliser le nom de membre.

struct mystruct {
    int member_a;
    int member_b;
}
struct mystruct *s = malloc(sizeof(struct mystruct));

Mettre une autre manière; Comment vous exprimer la suivante en termes de pointeurs/offsets:

s->member_b = 3;
printf("%i",s->member_b);

Ma conjecture est à

  • calculer le décalage par trouver le sizeof l'member_a (int)
  • fonte de la structure à un seul mot de type pointeur (char?)
  • créer un int pointeur et réglez l'adresse (pour les *charpointer + offset?)
  • utiliser mon int pointeur pour définir le contenu de la mémoire

mais je suis un peu confus au sujet de la conversion vers un type char ou si quelque chose comme memset est plus adéquat ou si en général je suis aproching ce totalement faux.

Bravo pour toute aide

  • Pourquoi voulez-vous faire cela?
  • Je suis combler un écart entre un environnement de script et les C-extensions, (pensez à Python, C-Types), et je suis à la définition et à l'accès aux structures lors de l'exécution.
  • Alors vous êtes la génération de code C? Dans ce cas, vous pouvez générer du code C pour accéder les membres de la structure aussi. Fait que j'ai mal compris?
InformationsquelleAutor Chris Farmiloe | 2010-01-11
  1. 32

    L'approche que vous avez décrit est à peu près correct, bien que vous devriez utiliser offsetof au lieu de tenter de comprendre le décalage sur votre propre. Je ne suis pas sûr de savoir pourquoi vous mentionner memset -- il définit le contenu d'un bloc à une certaine valeur, ce qui semble tout à fait sans rapport avec la question à portée de main.

    Voici un peu de code pour montrer comment il fonctionne:

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

typedef struct x {
    int member_a;
    int member_b;
} x;

int main() { 
    x *s = malloc(sizeof(x));
    char *base;
    size_t offset;
    int *b;

    //initialize both members to known values
    s->member_a = 1;
    s->member_b = 2;

    //get base address
    base = (char *)s;

    //and the offset to member_b
    offset = offsetof(x, member_b);

    //Compute address of member_b
    b = (int *)(base+offset);

    //write to member_b via our pointer
    *b = 10;

    //print out via name, to show it was changed to new value.
    printf("%d\n", s->member_b);
    return 0;
}
    • merci pour votre réponse, memset était juste un passage de l'idée, puisque c'était juste une autre façon d'écrire la mémoire à une adresse, C'était plus une question de "ne pas me tenir à ma méthode, je suis ouvert à le faire d'une autre manière" commentaire 🙂 Le décalage est actaully une part je suis très bien avec, c'est la façon de compenser un vide pointeur je pense que je suis aux prises avec.... est-il convenable de jeter mon struct pointeur vers char*, par exemple?
    • Ou: ((struct mystruct *)p)->member_b = 3;
    InformationsquelleAutor Jerry Coffin
  2. 26

    La technique entière:

    1. Obtenir le décalage à l'aide de offsetof:

      b_offset = offsetof(struct mystruct, member_b);

    2. Obtenir l'adresse de votre structure en tant que char * pointeur.

      char *sc = (char *)s;

    3. Ajouter un offset à la structure de l'adresse, la fonte de la valeur à un pointeur sur le type et le déréférencement:

      *(int *)(sc + b_offset)

    • +1 pour le portable de la méthode lien
    InformationsquelleAutor R Samuel Klatchko
  3. 4

    Ignorant de rembourrage et de l'alignement, comme vous l'avez dit...

    Si les éléments que vous avez pointant vers sont entièrement d'un seul type, comme dans votre exemple, vous pouvez juste lancer la structure, du type désiré et de le traiter comme un tableau:

    printf("%i", ((int *)(&s))[1]);
    • +1 pour repérer le tableau, et d'obtenir un sournois raccourci 🙂 malheureusement, mon structs peut contenir différents types de
    InformationsquelleAutor mskfisher
  4. 3

    Il est possible de calculer le décalage basé sur la structure et la valeur NULL comme pointeur de référence
    e.g " &(((type *)0)->champ)"

    Exemple:

    struct my_struct {
    int x;
    int y;
    int *m;
    int *h;
};
int main()
{
    printf("offset %d\n", (int) &((((struct my_struct*)0)->h)));
    return 0;
}
    InformationsquelleAutor Obik
  5. 1

    Dans cet exemple particulier, vous pouvez vous adresser par *((int *) ((char *) s + sizeof(int))). Je ne suis pas sûr de savoir pourquoi vous voulez, donc je suis en supposant un but didactique, donc l'explication de la façon suivante.

    Les bits de code se traduit comme: prenez la mémoire commençant à l'adresse s et de la traiter comme de la mémoire pointant vers char. À cette adresse, ajouter sizeof(int) char-morceaux - vous obtenir une nouvelle adresse. Prendre la valeur de l'adresse ainsi créé et la traiter comme une int.

    Remarque que l'écriture *(s + sizeof(int)) donnerait l'adresse à s plus sizeof(int) sizeof(mystruct) morceaux

    Edit: comme par Andrey commentaire, à l'aide de offsetof:

    *((int *) ((byte *) s + offsetof(struct mystruct, member_b)))

    Edit 2: j'ai remplacé tous les bytes avec chars comme sizeof(char) est garantie 1.

    • Pourquoi voudriez-vous utiliser byte et pas char? Aussi ((byte *) s + sizeof(int)) est de type byte *, qui est le même que char *, sorte de déférence, il (peut) pas de vous donner un int - si sizeof(int) != sizeof(char). Vous avez besoin d'un plâtre pour int * avant d'être déréférencé.
    • Correct, partiellement votre exemple est plus didactique. J'ai utilisé octet parce que je pense qu'il est plus didactique sens. Notez cependant que, sizeof(byte) pourrait ne pas être égale à sizeof(char), en fonction de l'architecture.
    • N'est pas correcte. Dans ordert pour accéder à la member_b champ, vous devez ajouter offsetof(mystruct, member_b) qui n'est pas nécessairement le même que sizeof(int).
    • Et qu'est-ce que byte? La norme ne définit pas elle. Aussi, si sizeof(byte) != sizeof(char), alors vous voulez certainement char et pas byte dans votre code depuis sizeof(char) est 1.
    • AndreyT: je n'ai laisser ignorer rembourrage questions, afin de sizeof/offset peut être considérée comme même. Laura: merci qu'il a fait pour moi!
    • c'est exact, je vais modifier pour refléter le fait que
    • Je suis d'accord, offsetof est mieux, j'ai été de tenter de "corriger" laura du code sans changer sa forme (je sais même alors, il n'est pas correct).
    • ne peut pas être coinsidered "la même" dans ce cas, indépendamment de ce que vous avez autorisé.
    • en fait le C standard ne définir "octet" -- c'est la quantité de stockage nécessaire pour un char. OIE, dans la mesure du C (et C++) de soins, 'octet' et de 'char' sont pratiquement interchangeables.
    • pas correct, même maintenant. Vous souhaitez offsetof(struct mystruct, member_b), ou mieux: ((struct mystruct *)s)->member_b = 3;
    • non pas comme un type bien. Sans typedef, le casting (byte *) ne veut rien dire en C.
    • Je pense qu'il voulait éviter à l'aide de ((struct mystruct *)s)->member_b = 3;.

    InformationsquelleAutor laura
  6. 0

    Il sons de vos commentaires que ce que vous êtes vraiment en train de faire est de l'emballage et déballage de tout un tas de différents types de données dans un seul bloc de mémoire. Alors que vous peut s'en tirer avec faire avec pointeur direct jette, comme la plupart des autres réponses ont suggéré:

    void set_int(void *block, size_t offset, int val)
{
    char *p = block;

    *(int *)(p + offset) = val;
}

int get_int(void *block, size_t offset)
{
    char *p = block;

    return *(int *)(p + offset);
}

    Le problème est que c'est non portable. Il n'y a pas en général de façon à s'assurer que les types sont stockés dans votre bloc avec l'alignement correct de la, et certaines architectures ne peut tout simplement pas les charges ou les magasins de non-alignées adresses. Dans le cas particulier où la mise en page de votre bloc est défini par une déclaration de structure, il sera OK, parce que la structure de mise en page comprendra le nécessaire rembourrage pour assurer l'alignement à droite. Cependant, comme vous ne pouvez pas accéder aux membres par leur nom, on dirait que ce n'est pas vraiment ce que vous faites.

    Pour ce faire de façon portable, vous avez besoin d'utiliser memcpy:

    void set_int(void *block, size_t offset, int val)
{
    char *p = block;

    memcpy(p + offset, &val, sizeof val);
}

int get_int(void *block, size_t offset)
{
    char *p = block;
    int val;

    memcpy(&val, p + offset, sizeof val);
    return val;
}

    (similaire pour les autres types).

    InformationsquelleAutor caf