ukuran anggota struct tunggal di C

Saya mencoba mendeklarasikan struct yang bergantung pada struct lain. Saya ingin menggunakan sizeofuntuk menjadi aman / bertele-tele.

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

Sekarang saya ingin mendeklarasikan struct child_tyang memiliki ukuran yang sama dengan parent_t.text.

Bagaimana saya bisa melakukan ini? (Pseudo-code di bawah.)

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

Saya mencoba beberapa cara berbeda dengan parent_tdan struct _parent, tetapi kompiler saya tidak mau menerimanya.

Sebagai trik, ini sepertinya berhasil:

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

Apakah mungkin untuk mendeklarasikan child_ttanpa menggunakan dummy?

Meskipun menentukan ukuran buffer dengan a #defineadalah salah satu cara idiomatik untuk melakukannya, cara lain adalah menggunakan makro seperti ini:

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

dan gunakan seperti ini:

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

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

Saya sebenarnya sedikit terkejut bahwa sizeof((type *)0)->member)itu bahkan diizinkan sebagai ekspresi konstan. Barang keren.

Saat ini saya tidak menggunakan mesin pengembangan, tetapi menurut saya Anda dapat melakukan salah satu dari yang berikut:

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

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

Anda bebas menggunakan FIELD_SIZEOF(t, f)kernel Linux. Ini hanya didefinisikan sebagai berikut:

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

Jenis makro ini disebutkan dalam jawaban lain. Tapi lebih portabel menggunakan makro yang sudah ditentukan.

Gunakan arahan preprocessor, yaitu #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 ;

Anda dapat menggunakan arahan preprocessor untuk ukuran sebagai:

#define TEXT_MAX_SIZE 255

dan menggunakannya untuk orang tua dan anak.

struct.h apakah sudah ditentukan,

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

jadi kamu bisa,

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

Namun, saat melihat di header, tampaknya ini adalah hal BSD dan bukan standar ANSI atau POSIX. Saya mencobanya di mesin Linux dan tidak berhasil; kegunaan terbatas.

Kemungkinan lain adalah menentukan tipe. Fakta bahwa Anda ingin memastikan ukuran yang sama untuk dua bidang adalah indikator bahwa Anda memiliki semantik yang sama untuk mereka, saya kira.

typedef char description[255];

dan kemudian memiliki bidang

description text;

di kedua tipe Anda.

solusi c ++:

sizeof (Type :: member) tampaknya berfungsi dengan baik:

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

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

@ joey-adams, terima kasih! Saya mencari hal yang sama, tetapi untuk non char array dan itu berfungsi dengan baik bahkan dengan cara ini:

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

Ini mengembalikan 20 seperti yang diharapkan.

Dan, @ brandon-horsley, ini juga berfungsi dengan baik:

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