taille d'un membre de structure unique en C

J'essaye de déclarer une structure qui dépend d'une autre structure. Je veux utiliser sizeofpour être sûr / pédant.

typedef struct _parent
{
  float calc ;
  char text[255] ;
  int used ;
} parent_t ;

Maintenant, je veux déclarer une structure child_tqui a la même taille que parent_t.text.

Comment puis-je faire ceci? (Pseudo-code ci-dessous.)

typedef struct _child
{
  char flag ;
  char text[sizeof(parent_t.text)] ;
  int used ;
} child_t ;

J'ai essayé différentes méthodes avec parent_tet struct _parent, mais mon compilateur n'acceptera pas.

En guise d'astuce, cela semble fonctionner:

parent_t* dummy ;
typedef struct _child
{
  char flag ;
  char text[sizeof(dummy->text)] ;
  int used ;
} child_t ;

Est-il possible de déclarer child_tsans utiliser de dummy?

Bien que définir la taille de la mémoire tampon avec un #definesoit une façon idiomatique de le faire, une autre serait d'utiliser une macro comme celle-ci:

#define member_size(type, member) sizeof(((type *)0)->member)

et utilisez-le comme ceci:

typedef struct
{
    float calc;
    char text[255];
    int used;
} Parent;

typedef struct
{
    char flag;
    char text[member_size(Parent, text)];
    int used;
} Child;

Je suis en fait un peu surpris que ce sizeof((type *)0)->member)soit même autorisé comme expression constante. Truc cool.

Je ne suis pas sur ma machine de développement pour le moment, mais je pense que vous pouvez effectuer l'une des opérations suivantes:

sizeof(((parent_t *)0)->text)

sizeof(((parent_t){0}).text)

Vous êtes libre d'utiliser FIELD_SIZEOF(t, f)dans le noyau Linux. Il est simplement défini comme suit:

#define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))

Ce type de macro est mentionné dans d'autres réponses. Mais il est plus portable d'utiliser une macro déjà définie.

Utilisez une directive de préprocesseur, c'est-à-dire #define:

#define TEXT_LEN 255

typedef struct _parent
{
  float calc ;
  char text[TEXT_LEN] ;
  int used ;
} parent_t ;

typedef struct _child
{
  char flag ;
  char text[TEXT_LEN] ;
  int used ;
} child_t ;

Vous pouvez utiliser une directive de préprocesseur pour la taille comme:

#define TEXT_MAX_SIZE 255

et utilisez-le à la fois chez le parent et l'enfant.

struct.h les a déjà définis,

#define fldsiz(name, field) \
    (sizeof(((struct name *)0)->field))

pour que tu puisses,

#include <stdlib.h> /* EXIT_SUCCESS */
#include <stdio.h>  /* printf */
#include <struct.h> /* fldsiz */

struct Penguin {
    char name[128];
    struct Penguin *child[16];
};
static const int name_size  = fldsiz(Penguin, name) / sizeof(char);
static const int child_size = fldsiz(Penguin, child) / sizeof(struct Penguin *);

int main(void) {
    printf("Penguin.name is %d chars and Penguin.child is %d Penguin *.\n",
           name_size, child_size);
    return EXIT_SUCCESS;
}

mais, en regardant dans l'en-tête, il semble que ce soit une chose BSD et non ANSI ou POSIX standard. Je l'ai essayé sur une machine Linux et cela n'a pas fonctionné; utilité limitée.

Une autre possibilité serait de définir un type. Le fait que vous vouliez assurer la même taille pour les deux champs est un indicateur que vous avez la même sémantique pour eux, je pense.

typedef char description[255];

puis avoir un champ

description text;

dans vos deux types.

solution c ++:

sizeof (Type :: member) semble également fonctionner:

struct Parent
{
    float calc;
    char text[255];
    int used;
};

struct Child
{
    char flag;
    char text[sizeof(Parent::text)];
    int used;
};

@ joey-adams, merci! Je cherchais la même chose, mais pour un tableau non char et cela fonctionne parfaitement bien même de cette façon:

#define member_dim(type, member) sizeof(((type*)0)->member) / \
                                 sizeof(((type*)0)->member[0])

struct parent {
        int array[20];
};

struct child {
        int array[member_dim(struct parent, array)];
};

int main ( void ) {
        return member_dim(struct child, array);
}

Il renvoie 20 comme prévu.

Et, @ brandon-horsley, cela fonctionne bien aussi:

#define member_dim(type, member) sizeof(((type){0}).member) / \
                                 sizeof(((type){0}).member[0])