sizeof tek yapı üyesi C

Başka bir yapıya bağımlı olan bir yapı bildirmeye çalışıyorum. sizeofGüvenli / bilgiçlikçi olmak için kullanmak istiyorum .

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

Şimdi child_tile aynı boyutta bir yapı bildirmek istiyorum parent_t.text.

Bunu nasıl yapabilirim? (Aşağıdaki sözde kod.)

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

Ben birkaç farklı şekilde çalıştı parent_tve struct _parentancak benim derleyici kabul etmeyecektir.

Bir numara olarak, bu işe yarıyor gibi görünüyor:

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

O bildirmek mümkün mü child_tkullanılmadan dummy?

Arabellek boyutunu a ile tanımlamak #definedeyimsel bir yol olsa da, başka bir yöntem şöyle bir makro kullanmak olacaktır:

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

ve şu şekilde kullanın:

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

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

Aslında sizeof((type *)0)->member)sabit bir ifade olmasına izin verildiğine biraz şaşırdım . Güzel şeyler.

Şu anda geliştirme makinemde değilim, ancak aşağıdakilerden birini yapabileceğinizi düşünüyorum:

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

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

FIELD_SIZEOF(t, f)Linux çekirdeğini kullanmakta özgürsünüz . Sadece şu şekilde tanımlanır:

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

Bu tür makrolardan başka cevaplarda bahsedilmektedir. Ancak önceden tanımlanmış bir makroyu kullanmak daha taşınabilirdir.

Bir önişlemci yönergesi kullanın, yani #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 ;

Boyut için bir önişlemci yönergesini şu şekilde kullanabilirsiniz:

#define TEXT_MAX_SIZE 255

ve bunu hem ebeveynde hem de çocukta kullanın.

struct.h zaten tanımlanmış mı

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

böylece yapabilirsin

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

ancak başlığa bakıldığında, bunun bir BSD olayı olduğu ve ANSI veya POSIX standardı olmadığı anlaşılıyor. Bunu bir Linux makinesinde denedim ve işe yaramadı; sınırlı kullanışlılık.

Bir başka olasılık da bir tür tanımlamak olabilir. İki alan için de aynı büyüklükte olmasını sağlamak istemeniz, onlar için aynı anlamlara sahip olduğunuzun bir göstergesi sanırım.

typedef char description[255];

ve sonra bir tarla var

description text;

her iki türünüzde.

c ++ çözümü:

sizeof (Type :: member) da çalışıyor gibi görünüyor:

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

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

@ joey-adams, teşekkür ederim! Ben de aynı şeyi arıyordum, ancak char olmayan dizi için ve şu şekilde bile mükemmel çalışıyor:

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

Beklendiği gibi 20 döndürür.

Ve @ brandon-horsley, bu da iyi çalışıyor:

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