tamaño de un solo miembro de estructura en C

Estoy tratando de declarar una estructura que depende de otra estructura. Quiero usar sizeofpara ser seguro / pedante.

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

Ahora quiero declarar una estructura child_tque tenga el mismo tamaño que parent_t.text.

¿Cómo puedo hacer esto? (Pseudocódigo a continuación).

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

Intenté algunas formas diferentes con parent_ty struct _parent, pero mi compilador no acepta.

Como truco, esto parece funcionar:

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

¿Es posible declarar child_tsin el uso de dummy?

Aunque definir el tamaño del búfer con a #definees una forma idiomática de hacerlo, otra sería usar una macro como esta:

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

y utilícelo así:

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

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

De hecho, estoy un poco sorprendido de que sizeof((type *)0)->member)incluso se permita como una expresión constante. Cosas interesantes.

No estoy en mi máquina de desarrollo en este momento, pero creo que puede hacer una de las siguientes cosas:

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

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

Puede utilizarlo FIELD_SIZEOF(t, f)en el kernel de Linux. Simplemente se define de la siguiente manera:

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

Este tipo de macro se menciona en otras respuestas. Pero es más portátil usar una macro ya definida.

Utilice una directiva de preprocesador, es decir, #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 ;

Puede utilizar una directiva de preprocesador para el tamaño como:

#define TEXT_MAX_SIZE 255

y utilícelo tanto en padres como en niños.

struct.h los tiene ya definidos,

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

para que pudieras

#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;
}

pero, al mirar en el encabezado, parece que esto es una cosa BSD y no un estándar ANSI o POSIX. Lo probé en una máquina Linux y no funcionó; utilidad limitada.

Otra posibilidad sería definir un tipo. El hecho de que desee garantizar el mismo tamaño para los dos campos es un indicador de que tiene la misma semántica para ellos, creo.

typedef char description[255];

y luego tener un campo

description text;

en ambos tipos.

solución c ++:

sizeof (Type :: member) parece estar funcionando también:

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

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

@ joey-adams, ¡gracias! Estaba buscando lo mismo, pero para una matriz sin caracteres y funciona perfectamente bien incluso de esta manera:

#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);
}

Devuelve 20 como se esperaba.

Y, @ brandon-horsley, esto también funciona bien:

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