sizeof einzelnen struct-member in C

Ich versuche zu erklären, eine Struktur, die abhängig von anderen struct.
Ich will sizeof um sicher zu sein/pedantisch.

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

Nun möchte ich deklarieren struct child_t hat die gleiche Größe wie parent_t.text.

Wie kann ich dies tun? (Pseudo-code unten).

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

Ich habe versucht ein paar verschiedene Möglichkeiten, mit parent_t und struct _parent, aber mein compiler nicht akzeptieren.

Als ein trick, das scheint zu funktionieren:

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

Ist es möglich zu erklären child_t ohne den Einsatz von dummy?

InformationsquelleAutor kevinarpe | 2010-08-24

c sizeof struct

179

Obwohl die Festlegung der Puffergröße mit einem #define ist ein idiomatischer Weg, es zu tun, eine andere wäre ein makro wie dieses:
```
#define member_size(type, member) sizeof(((type *)0)->member)
```
und verwenden Sie es wie diese:
```
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) ist sogar erlaubt, da ein konstanter Ausdruck. Coole Sachen.
- Wow, ich wusste nicht, sizeof((type *)0)->member) arbeitet. Bin nicht auf meine dev-Maschine jetzt, aber funktioniert das für alle Compiler? Vielen Dank Joey.
- Ja, das funktioniert für alle Compiler. Der operand sizeof wird nicht ausgewertet, es gibt also kein Problem mit der Dereferenzierung der null-Zeiger (denn es ist eigentlich nicht dereferenziert).
- Wow!!! Viele kudos für dieses wunderbare Kleinod 🙂
- wunderbar? seine schlichte C89 finden Sie unter Implementierung von "offsetof" in <stddef.h> oder die gleiche Implementierung eetimes.com/design/other/4024941/...
- Danke. Noch ein Kleinod und für mich wunderbar.
- Hi kann mir jemand erklären sizeof(((type *)0)->Mitglied. Ich bin nicht in der Lage, daraus Sinn zu machen 🙁
- Hier, sizeof folgert die Art der ((type *)0)->member, und gibt die Größe eines Typs. ((type *)0) wird einfach ein null-pointer des struct-Typ. ptr->Mitglied ist (zur compile-Zeit) ein Ausdruck, dessen Typ der ist, dass das Mitglied. Der code innerhalb des sizeof nie läuft (wenn es das täte, würde das Programm segmentation Fault!). Nur der Typ der Wert innerhalb des sizeof geschaut wird.
- Wikipedia-Seite für offset_of Hinweise diese als Undefiniertes Verhalten gemäß dem C-standard, also ich würde nicht darauf Wetten, arbeiten mit allen Compilern.
InformationsquelleAutor Joey Adams
27

Ich bin nicht auf meiner Entwicklungs-Maschine jetzt, aber ich denke, man kann eines der folgenden:
```
sizeof(((parent_t *)0)->text)

sizeof(((parent_t){0}).text)
```
Bearbeiten: ich mag die member_size makro Joey schlug die Verwendung dieser Technik, ich denke, ich würde die verwenden.
- Sollte parent_t *, nicht _parent *.
- C99-feature!!!.
- Die zweite form ist sehr schön (und konzeptionell sauber, dass es sich nicht um null-Zeiger), aber man sollte erwähnen, dass es nicht möglich ist in pre-C99-Compiler.
InformationsquelleAutor Brandon Horsley
9

Verwenden Sie eine Präprozessor-Direktive, d.h. #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 ;
```
- einfachste. machen Sie es nicht kompliziert, es sei denn notwendig.
- Vereinbaren Sie mit Nyan. Die anderen Lösungen funktionieren, aber nicht erreichen, nichts anderes. Wenn Sie wollen mehr explizit, nennen es PARENT_TEXT_LEN oder etwas gleichermaßen beschreibend. Dann können Sie es auch verwenden, in der Bedingungen im gesamten code zu verhindern Puffer-Länge Fehler, und es werden dabei einfache integer-Vergleiche.
- ich denke, der Vorteil des sizeof-Lösung ist, dass Sie nicht brauchen Zugriff auf die übergeordnete Struktur, wenn es definiert ist, in einer Bibliothek oder sonst irgendwo.
- aber Sie wissen: "char text[member_size(Elternteil, text)];" Du musst den Verweis auf die "Eltern".
- ich glaube nicht, dass Sie mich verstanden. angenommen, die übergeordnete Struktur ist drand48_data (definiert in stdlib.h), und wollen Sie den sizeof -__x. Sie können nicht #define X_LEN 3 und ändern der stdlib.h, mit member_size überlegen ist, wenn Sie nicht haben Zugang zu der Quelle des übergeordneten Struktur, die scheint wie eine vernünftige situation.
InformationsquelleAutor dave mankoff
7

Sind Sie frei zu verwenden FIELD_SIZEOF(t, f) im Linux-kernel.
Es ist nur wie folgt definiert:
```
#define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
```
Diese Art von makro ist bereits in anderen Antworten. Aber es ist mehr tragbar zu verwenden, ein bereits definiertes makro.
- FIELD_SIZEOF ist das makro verwendet, in modernen Linux-Kerneln, gefunden im linux/kernel.h
- Guter Fang
- Dies ist ein idiomatischer Weise in C im Allgemeinen, um die strukturmember Größe? Ist nicht solch ein makro in ein Standard in der modernen C noch?
- Meines Wissens gibt es keine entsprechende makro in der standard-C.
InformationsquelleAutor Dmitry
4

Können Sie eine Präprozessor-Direktive für Größe:
```
#define TEXT_MAX_SIZE 255
```
und verwenden Sie es in beide Eltern und Kind.
- yep, aber es ist nicht immer eine option: sagen, in linux /usr/include/bits/dirent.h die Größe der d_name Feld (struct direct / dirent) ist nicht definiert als DIRSIZ mehr, sondern hart codiert; so sizeof() scheint der einzige saubere Weg, um die Abhängigkeit
InformationsquelleAutor codaddict
4

Andere Möglichkeit wäre, einen Typ definieren. Die Tatsache, dass Sie wollen sicherstellen, dass die gleiche Größe für die beiden Felder ist ein Indikator dafür, dass Sie die gleiche Semantik haben für Sie, denke ich.
```
typedef char description[255];
```
haben und dann ein Feld
```
description text;
```
in beiden Typen.

InformationsquelleAutor Jens Gustedt

struct.h hat Sie bereits definiert sind,

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

so könnte man,

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

aber, auf der Suche in der Kopfzeile, es scheint, dass dies ist ein BSD-Sache und nicht die ANSI-oder POSIX-standard. Ich versuchte es auf einer Linux-Maschine und es hat nicht funktioniert; von begrenztem nutzen.

InformationsquelleAutor Neil Edelman

c++ - Lösung:

sizeof(Type::Mitglied) zu sein scheint, so gut funktioniert:

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

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

Die Frage ist C, nicht C++.
du hast Recht, aber ich fand es hilfreich.

InformationsquelleAutor korish

@joey-adams, ich danke Ihnen!
Ich war auf der Suche die gleiche Sache, aber für nicht char-array und es funktioniert einwandfrei sogar auf diese Weise:

#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 gibt 20 zurück, wie erwartet.

Und @brandon-horsley, dies funktioniert auch gut:

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

InformationsquelleAutor Grandma

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.