sizeof thành viên cấu trúc đơn trong C

Tôi đang cố gắng khai báo một cấu trúc phụ thuộc vào một cấu trúc khác. Tôi muốn sử dụng sizeofđể được an toàn / đáng tin cậy.

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

Bây giờ tôi muốn khai báo một cấu trúc child_tcó cùng kích thước với parent_t.text.

Tôi có thể làm cái này như thế nào? (Mã giả bên dưới.)

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

Tôi đã thử một vài cách khác nhau với parent_t và struct _parent, nhưng trình biên dịch của tôi sẽ không chấp nhận.

Như một mẹo nhỏ, điều này dường như hoạt động:

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

Có thể khai báo child_tmà không sử dụng dummy?

Mặc dù việc xác định kích thước vùng đệm bằng a #definelà một cách khá dễ hiểu, nhưng một cách khác sẽ là sử dụng macro như sau:

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

và sử dụng nó như thế này:

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

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

Tôi thực sự hơi ngạc nhiên rằng sizeof((type *)0)->member)nó thậm chí còn được cho phép như một biểu thức không đổi. Những thứ tuyệt vời.

Tôi không ở trên máy phát triển của mình ngay bây giờ, nhưng tôi nghĩ bạn có thể thực hiện một trong những cách sau:

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

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

Bạn có thể sử dụng miễn phí FIELD_SIZEOF(t, f)trong nhân Linux. Nó chỉ được định nghĩa như sau:

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

Loại macro này được đề cập trong các câu trả lời khác. Nhưng sẽ dễ di chuyển hơn khi sử dụng macro đã được xác định.

Sử dụng chỉ thị tiền xử lý, tức là #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 ;

Bạn có thể sử dụng chỉ thị tiền xử lý cho kích thước như:

#define TEXT_MAX_SIZE 255

và sử dụng nó cho cả cha và con.

struct.h chúng đã được xác định chưa,

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

vì vậy bạn có thể,

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

nhưng, khi nhìn vào tiêu đề, có vẻ như đây là thứ BSD chứ không phải tiêu chuẩn ANSI hoặc POSIX. Tôi đã thử nó trên một máy Linux và nó không hoạt động; tính hữu dụng hạn chế.

Một khả năng khác là xác định một kiểu. Tôi nghĩ rằng việc bạn muốn đảm bảo cùng một kích thước cho hai trường là một dấu hiệu cho thấy bạn có cùng ngữ nghĩa cho chúng.

typedef char description[255];

và sau đó có một lĩnh vực

description text;

trong cả hai loại của bạn.

giải pháp c ++:

sizeof (Loại :: thành viên) dường như cũng đang hoạt động:

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

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

@ joey-adams, cảm ơn bạn! Tôi đã tìm kiếm điều tương tự, nhưng đối với mảng không phải char và nó hoạt động hoàn toàn tốt ngay cả theo cách này:

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

Nó trả về 20 như mong đợi.

Và, @ brandon-horseley, điều này cũng hoạt động tốt:

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