dimensione del singolo membro della struttura in C

Sto cercando di dichiarare una struttura che dipende da un'altra struttura. Voglio usare sizeofper essere sicuro / pedante.

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

Ora voglio dichiarare una struttura child_tche ha la stessa dimensione di parent_t.text.

Come posso fare questo? (Pseudo-codice di seguito.)

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

Ho provato diversi modi con parent_te struct _parent, ma il mio compilatore non accetta.

Come trucco, sembra funzionare:

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

È possibile dichiarare child_tsenza l'uso di dummy?

Sebbene definire la dimensione del buffer con a #definesia un modo idiomatico per farlo, un altro sarebbe usare una macro come questa:

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

e usalo in questo modo:

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

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

In realtà sono un po 'sorpreso che sizeof((type *)0)->member)sia persino consentita come espressione costante. Roba forte.

Al momento non sono sulla mia macchina di sviluppo, ma penso che tu possa eseguire una delle seguenti operazioni:

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

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

Sei libero di usare FIELD_SIZEOF(t, f)nel kernel Linux. È semplicemente definito come segue:

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

Questo tipo di macro è menzionato in altre risposte. Ma è più portabile usare una macro già definita.

Usa una direttiva del preprocessore, ad esempio #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 ;

È possibile utilizzare una direttiva del preprocessore per la dimensione come:

#define TEXT_MAX_SIZE 255

e usalo sia nel genitore che nel figlio.

struct.h li ha già definiti,

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

così potresti

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

ma, guardando nell'intestazione, sembra che questa sia una cosa BSD e non standard ANSI o POSIX. L'ho provato su una macchina Linux e non ha funzionato; utilità limitata.

Un'altra possibilità sarebbe definire un tipo. Il fatto che tu voglia garantire la stessa dimensione per i due campi è un indicatore del fatto che hai la stessa semantica per loro, credo.

typedef char description[255];

e poi avere un campo

description text;

in entrambi i tuoi tipi.

soluzione c ++:

Anche sizeof (Type :: member) sembra funzionare:

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

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

@ joey-adams, grazie! Stavo cercando la stessa cosa, ma per array non char e funziona perfettamente anche in questo modo:

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

Restituisce 20 come previsto.

E, @ brandon-horsley, anche questo funziona bene:

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