sizeof pojedynczego elementu struktury w C

Próbuję zadeklarować strukturę, która jest zależna od innej struktury. Chcę sizeofbyć bezpieczny / pedantyczny.

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

Teraz chcę zadeklarować strukturę, child_tktóra ma taki sam rozmiar jak parent_t.text.

W jaki sposób mogę to zrobić? (Pseudokod poniżej).

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

Próbowałem na kilka różnych sposobów z parent_ti struct _parent, ale mój kompilator nie akceptuje.

Wydaje się, że to działa:

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

Czy można złożyć deklarację child_tbez użycia dummy?

Chociaż zdefiniowanie rozmiaru bufora za pomocą a #definejest idiomatycznym sposobem, aby to zrobić, innym byłoby użycie makra takiego:

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

i użyj go w ten sposób:

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

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

Właściwie jestem trochę zaskoczony, że sizeof((type *)0)->member)jest to dozwolone nawet jako ciągłe wyrażenie. Fajne rzeczy.

Nie jestem teraz na moim komputerze deweloperskim, ale myślę, że możesz wykonać jedną z następujących czynności:

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

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

Możesz swobodnie używać FIELD_SIZEOF(t, f)w jądrze Linuksa. Jest zdefiniowany w następujący sposób:

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

Ten typ makra jest wymieniany w innych odpowiedziach. Ale bardziej przenośne jest użycie już zdefiniowanego makra.

Użyj dyrektywy preprocesora, tj. #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 ;

Możesz użyć dyrektywy preprocesora dla rozmiaru jako:

#define TEXT_MAX_SIZE 255

i używaj go zarówno u rodzica, jak i dziecka.

struct.h ma je już zdefiniowane,

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

więc mógłbyś

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

ale patrząc w nagłówek, okazuje się, że jest to sprawa BSD, a nie standard ANSI czy POSIX. Wypróbowałem to na komputerze z Linuksem i nie działało; ograniczona przydatność.

Inną możliwością byłoby zdefiniowanie typu. Fakt, że chcesz zapewnić ten sam rozmiar dla dwóch pól, jest wskaźnikiem, że masz dla nich taką samą semantykę, jak sądzę.

typedef char description[255];

a potem mieć pole

description text;

w obu twoich typach.

rozwiązanie C ++:

Wygląda na to, że sizeof (Type :: member) również działa:

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

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

@ joey-adams, dziękuję! Szukałem tego samego, ale dla tablicy non char i działa doskonale nawet w ten sposób:

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

Zwraca 20 zgodnie z oczekiwaniami.

@ Brandon-horsley, to też działa dobrze:

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