C: tamaño del miembro de una sola estructura

sizeof

Question

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

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

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

¿Cómo puedo hacer esto? (Pseudo-código a continuación)

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

Intenté algunas maneras diferentes con parent_t y struct _parent , pero mi compilador no aceptará.

Como un 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_t sin el uso de dummy ?

Answer 1

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

Answer 2

@ joey-adams, gracias! Estaba buscando lo mismo, pero para array no char 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])

Answer 3

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

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

y úsalo 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) esté permitido como una expresión constante. Cosas interesantes.

Answer 4

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) Editar : me gusta la macro member_size que Joey sugirió usando esta técnica, creo que usaría eso.

Answer 5

Otra posibilidad sería definir un tipo. El hecho de que quiera 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 tienes un campo

description text;

en ambos tipos.

Answer 6

Puede usar una directiva de preprocesador para tamaño como:

#define TEXT_MAX_SIZE 255

y usarlo tanto en padres como en hijos.

Answer 7

Usted es libre de usar sizeof_field(type, filed) en Linux. Simplemente se define de la siguiente manera:

#define sizeof_field(type,field)  (sizeof(((type *)0)->field))

eso es mencionado arriba. Pero es más portátil usar macro ya definida.

Answer 8

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 ;

Answer 9

struct.h 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 buscar en el encabezado, parece que esto es algo BSD y no un estándar ANSI o POSIX. Lo probé en una máquina Linux y no funcionó; utilidad limitada