Warum werden Typedef-Namen in der Struct-Deklaration in C zweimal verwendet?

Bei der Erforschung von Warteschlangen in C bin ich auf ein Beispiel gestoßen, das dem folgenden ähnelt. Warum wird die Struktur sowohl am Anfang der geschweiften Klammern als auch danach benannt? Warum wird der Strukturtyp innerhalb der Struktur erneut verwendet, wenn ein Element desselben Typs hinzugefügt wird? Sind diese Dinge überflüssig oder gibt es einen Punkt?

typedef void* vpoint_t;

typedef struct queue_item_t{
  vpoint_t void_item;
  struct queue_item_t* next;
} queue_item_t;

typedef struct queue_item_t {     // 1
  vpoint_t void_item;
  struct queue_item_t* next;      // 2
} queue_item_t;                   // 3

Beachten Sie zunächst, dass diese gesamte Anweisung a definiert typedef.

3) Sagt, dass der neue Typ, den wir gerade definieren (via typedef) ist gehen zu benannt werden queue_item_t.

1) Der Name der Struktur (die im Laufe der Zeit einen neuen Namen erhält) wird benannt struct queue_item_t. Das ist sein vollständiger Name, einschließlich struct vorne.

2) Da der neue Typ noch nicht existiert (denken Sie daran, wir sind noch dabei, ihn zu definieren), müssen wir den einzigen Namen verwenden, den er bisher hat, nämlich struct queue_item_taus 1).

Beachten Sie, dass Sie haben können anonym struct Definitionendie es Ihnen ermöglichen, den Namen wegzulassen 1). Ein einfaches Beispiel:

typedef struct {
   int x, y, z;
} vector3;

Da wir in Ihrem Beispiel jedoch die Struktur benötigen, um auf sich selbst verweisen zu können, wird die next Zeiger muss einen bereits definierten Typ haben. Wir können das durch vorwärts deklarieren die Struktur, typdefinieren Sie sie und definieren Sie dann die Struktur mit der typedefd Typ für next:

struct _queue_item;                           // 4

typedef struct _queue_item queue_item_t;      // 5

struct _queue_item {                          // 6
  vpoint_t void_item;
  queue_item_t* next;                         // 7
}

4) Erkläre das struct _queue_item existiert, gibt aber noch keine Definition dafür an.

5) Typdef queue_item_t gleich sein wie struct _queue_item.

6) Geben Sie jetzt die Definition der Struktur an …

7) …mit unserem typedef‘d queue_item_t.

Alles in allem … Meiner Meinung nach Bitte verwenden Sie keine Typedefs für Strukturen.

struct queue_item {
    void *data;
    struct queue_item *next;
}

ist einfach und vollständig. Sie können diese sechs zusätzlichen Zeichen eingeben.

Von dem Codierungsstil des Linux-Kernels:

Kapitel 5: Typedefs

Bitte verwenden Sie keine Dinge wie “vps_t”. Es ist ein Fehler Typedef für Strukturen und Zeiger zu verwenden. Wenn Sie ein sehen

  vps_t a;

in der Quelle, was bedeutet das? Im Gegensatz dazu, wenn es heißt

  struct virtual_container *a;

Sie können tatsächlich sagen, was “a” ist.

Es gibt Ausnahmen, die Sie nachlesen können.

Einige aktuelle verwandte Fragen:

• Warum sollte man anstelle eines typsicheren Strukturzeigers ein undurchsichtiges „Handle“ verwenden, das ein Casting in einer öffentlichen API erfordert?

• Unterbricht das Hin- und Herbewegen eines Zeigers von size_t oder uintptr_t das strikte Aliasing?

Ändern wir die Deklaration ein wenig, um die Diskussion leichter nachvollziehen zu können:

typedef struct queue_item {
  vpoint_t void_item;
  struct queue_item* next;
} QueueItemType;

C unterstützt mehrere verschiedene Namensräume; ein Namensraum ist reserviert Tag-Namen zu Unions, Strukturen und Aufzählungstypen. In diesem Fall ist der Tag-Name queue_item. Ein weiterer Namensraum ist für reguläre Bezeichner reserviert, einschließlich Typedef-Namen wie QueueItemType.

Das next member wird verwendet, um auf eine andere Instanz des Typs zu verweisen struct queue_item (dh das nächste Element in der Warteschlange). Es ist als Zeiger auf deklariert struct queue_item aus zwei Gründen:

• Ein Strukturtyp darf kein enthalten Beispiel von sich selbst; Zum einen müsste der Typ unendlich groß sein (struct queue_item enthält ein Mitglied nextdie ein struct queue_item die ein Mitglied enthält nextdie ein struct queue_item die ein Mitglied enthält next, Ad infinitum);

• Die Strukturtypdefinition ist es nicht Komplett bis zur Schließung }und Sie können kein deklarieren Beispiel von unvollständiger Art. Sie können jedoch a deklarieren Zeiger zu einem unvollständigen Typ, was wir unten tun:

  struct queue_item *nächster;

Warum nicht verwenden QueueItemType *next; Anstatt von struct queue_item *next? Auch hier ist die Strukturtypdefinition nicht Komplett am Punkt next wird deklariert; der typedef-Name QueueItemType existiert noch nicht. Allerdings ist der Tag-Name queue_item ist für den Compiler bereits sichtbar, sodass wir Zeiger mithilfe des Typs deklarieren können struct queue_item.

Da Tag-Namen und Typedef-Namen unterschiedliche Namensräume belegen, ist es möglich, denselben Namen ohne Kollision sowohl für den Tag-Namen als auch für den Typedef-Namen zu verwenden. Der Compiler unterscheidet zwischen den beiden durch das Vorhandensein von struct Stichwort.

Zunächst schlage ich vor, NIEMALS einen Strukturnamen und einen identischen Typnamen zu verwenden. Verwenden typedef struct QUEUE_ITEM {...} queue_item_t;

Zu der Frage: Wenn Sie eine “rekursive Datenstruktur” erstellen möchten, dh eine Datenstruktur, die Zeiger auf Instanzen von sich selbst enthält, müssen Sie dem Compiler sagen können: “Dieses Feld ist ein Zeiger auf eine von uns . Du weißt noch nicht ganz, wie wir aussehen, weil ich es noch definiere, also reserviere einfach Platz für einen Zeiger.“ Dazu erklärst du dich

struct T {
    ...
    struct T *ptr;
    ....
};

Mit dem Finale } queue_item_t; Sie erstellen einen neuen Namen für die Struktur.

“struct foo {…} ” ist eine Sache. Es definiert eine Struktur, Sie müssen an jeder Stelle, an der Sie sie verwenden, “struct foo” eingeben.

“typedef … foo” definiert einen neuen Typ, also geben Sie einfach “foo” dort ein, wo Sie es verwenden.

“typedef struct foo {…} foo” ist ein Idiom, also können Sie beide verwenden, höchstwahrscheinlich nur “foo”, um Tastatureingaben und visuelle Verschmutzung zu sparen.