Größe eines einzelnen Strukturelements in C.

Ich versuche eine Struktur zu deklarieren, die von einer anderen Struktur abhängig ist. Ich möchte verwenden sizeof, um sicher / pedantisch zu sein.

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

Jetzt möchte ich eine Struktur deklarieren child_t, die dieselbe Größe hat wie parent_t.text.

Wie kann ich das machen? (Pseudocode unten.)

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

Ich habe ein paar verschiedene Möglichkeiten mit parent_tund ausprobiert struct _parent, aber mein Compiler wird dies nicht akzeptieren.

Als Trick scheint dies zu funktionieren:

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

Ist es möglich, child_tohne die Verwendung von zu deklarieren dummy?

Obwohl das Definieren der Puffergröße mit a #defineeine idiomatische Methode ist, besteht eine andere darin, ein Makro wie das folgende zu verwenden:

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

und benutze es so:

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

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

Ich bin eigentlich ein bisschen überrascht, dass sizeof((type *)0)->member)das sogar als ständiger Ausdruck erlaubt ist. Cooles Zeug.

Ich bin gerade nicht auf meiner Entwicklungsmaschine, aber ich denke, Sie können eine der folgenden Aktionen ausführen:

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

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

Sie können FIELD_SIZEOF(t, f)den Linux-Kernel verwenden. Es ist nur wie folgt definiert:

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

Diese Art von Makro wird in anderen Antworten erwähnt. Es ist jedoch portabler, ein bereits definiertes Makro zu verwenden.

Verwenden Sie eine Präprozessor-Direktive, dh #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 ;

Sie können eine Präprozessor-Direktive für die Größe verwenden als:

#define TEXT_MAX_SIZE 255

und verwenden Sie es sowohl bei Eltern als auch bei Kindern.

struct.h hat sie schon definiert,

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

so könntest du,

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

Beim Betrachten des Headers scheint es sich jedoch um eine BSD-Sache zu handeln und nicht um einen ANSI- oder POSIX-Standard. Ich habe es auf einem Linux-Computer versucht und es hat nicht funktioniert. begrenzte Nützlichkeit.

Eine andere Möglichkeit wäre, einen Typ zu definieren. Die Tatsache, dass Sie für beide Felder die gleiche Größe sicherstellen möchten, ist ein Indikator dafür, dass Sie für sie die gleiche Semantik haben, denke ich.

typedef char description[255];

und dann ein Feld haben

description text;

in beiden Ihrer Typen.

C ++ - Lösung:

sizeof (Type :: member) scheint ebenfalls zu funktionieren:

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

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

@ Joey-Adams, danke! Ich habe das Gleiche gesucht, aber nach einem Array ohne Zeichen, und es funktioniert auch auf diese Weise einwandfrei:

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

Es wird wie erwartet 20 zurückgegeben.

Und @ brandon-horsley, das funktioniert auch gut:

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