selbstreferenzielle Strukturdefinition?

Ich habe C nicht sehr lange geschrieben und bin mir daher nicht sicher, wie ich diese Art von rekursiven Dingen ausführen soll ... Ich möchte, dass jede Zelle eine andere Zelle enthält, aber ich erhalte einen Fehler entlang der Zeilen von "Feld 'Kind' hat unvollständigen Typ". Was geht?

typedef struct Cell {
  int isParent;
  Cell child;
} Cell;

Es ist klar, dass eine Zelle keine andere Zelle enthalten kann, da dies zu einer nie endenden Rekursion wird.

Eine Zelle kann jedoch einen Zeiger auf eine andere Zelle enthalten.

typedef struct Cell {
  bool isParent;
  struct Cell* child;
} Cell;

In C können Sie nicht auf das Typedef verweisen, das Sie mit der Struktur selbst erstellen. Sie müssen den Strukturnamen wie im folgenden Testprogramm verwenden:

#include <stdio.h>
#include <stdlib.h>

typedef struct Cell {
  int cellSeq;
  struct Cell* next; /* 'tCell *next' will not work here */
} tCell;

int main(void) {
    int i;
    tCell *curr;
    tCell *first;
    tCell *last;

    /* Construct linked list, 100 down to 80. */

    first = malloc (sizeof (tCell));
    last = first;
    first->cellSeq = 100;
    first->next = NULL;
    for (i = 0; i < 20; i++) {
        curr = malloc (sizeof (tCell));
        curr->cellSeq = last->cellSeq - 1;
        curr->next = NULL;
        last->next = curr;
        last = curr;
    }

    /* Walk the list, printing sequence numbers. */

    curr = first;
    while (curr != NULL) {
        printf ("Sequence = %d\n", curr->cellSeq);
        curr = curr->next;
    }

    return 0;
}

Obwohl es im Standard wahrscheinlich viel komplizierter ist als dies, können Sie sich vorstellen, dass der Compiler struct Cellin der ersten Zeile der, typedefaber tCellerst in der letzten Zeile davon weiß :-) So erinnere ich mich an diese Regel.

Aus theoretischer Sicht können Sprachen nur selbstreferenzielle Strukturen unterstützen, keine selbstinklusiven Strukturen.

Es gibt eine Art Weg, dies zu umgehen:

struct Cell {
  bool isParent;
  struct Cell* child;
};

struct Cell;
typedef struct Cell Cell;

Wenn Sie es so deklarieren, teilt es dem Compiler ordnungsgemäß mit, dass struct Cell und plain-ol'-cell identisch sind. Sie können Cell also wie gewohnt verwenden. Die Strukturzelle muss jedoch immer noch in der ursprünglichen Deklaration selbst verwendet werden.

Ich weiß, dass dieser Beitrag alt ist. Um jedoch den gewünschten Effekt zu erzielen, sollten Sie Folgendes versuchen:

#define TAKE_ADVANTAGE

/* Forward declaration of "struct Cell" as type Cell. */
typedef struct Cell Cell;

#ifdef TAKE_ADVANTAGE
/*
   Define Cell structure taking advantage of forward declaration.
*/
struct Cell
{
   int isParent;
   Cell *child;
};

#else

/*
   Or...you could define it as other posters have mentioned without taking
   advantage of the forward declaration.
*/
struct Cell
{
   int isParent;
   struct Cell *child;
};

#endif

/*
    Some code here...
*/

/* Use the Cell type. */
Cell newCell;

In jedem der beiden im obigen Codefragment genannten Fälle MÜSSEN Sie Ihre untergeordnete Zellstruktur als Zeiger deklarieren. Wenn Sie dies nicht tun, wird der Fehler "Feld 'Kind' hat unvollständigen Typ" angezeigt. Der Grund dafür ist, dass "struct Cell" definiert werden muss, damit der Compiler weiß, wie viel Speicherplatz bei seiner Verwendung zugewiesen werden muss.

Wenn Sie versuchen, "struct Cell" in der Definition von "struct Cell" zu verwenden, kann der Compiler noch nicht wissen, wie viel Speicherplatz "struct Cell" einnehmen soll. Der Compiler weiß jedoch bereits, wie viel Speicherplatz ein Zeiger benötigt, und (mit der Vorwärtsdeklaration) weiß er, dass "Zelle" eine Art "Strukturzelle" ist (obwohl er noch nicht weiß, wie groß eine "Strukturzelle" ist ). Der Compiler kann also eine "Zelle *" innerhalb der Struktur definieren, die definiert wird.

Lassen Sie uns die grundlegende Definition von typedef durchgehen. typedef wird verwendet, um einen Alias ​​für einen vorhandenen Datentyp zu definieren, der entweder benutzerdefiniert oder integriert ist.

typedef <data_type> <alias>;

beispielsweise

typedef int scores;

scores team1 = 99;

Verwechslung besteht hier mit der selbstreferenziellen Struktur aufgrund eines Mitglieds desselben Datentyps, der zuvor nicht definiert wurde. Standardmäßig können Sie Ihren Code also wie folgt schreiben: -

//View 1
typedef struct{ bool isParent; struct Cell* child;} Cell;

//View 2
typedef struct{
  bool isParent;
  struct Cell* child;
} Cell;

//Other Available ways, define stucture and create typedef
struct Cell {
  bool isParent;
  struct Cell* child;
};

typedef struct Cell Cell;

Aber letzte Option erhöht einige zusätzliche Zeilen und Wörter mit normalerweise wollen wir nicht (wir sind so faul, wie Sie wissen;)). Also lieber View 2.

Eine andere bequeme Methode besteht darin, die Struktur mit dem Struktur-Tag wie folgt vorab zu definieren:

//declare new type 'Node', as same as struct tag
typedef struct Node Node;
//struct with structure tag 'Node'
struct Node
{
int data;
//pointer to structure with custom type as same as struct tag
Node *nextNode;
};
//another pointer of custom type 'Node', same as struct tag
Node *node;

Eine Struktur, die einen Verweis auf sich selbst enthält. Dies tritt häufig in einer Struktur auf, die einen Knoten für eine Verknüpfungsliste beschreibt. Jeder Knoten benötigt einen Verweis auf den nächsten Knoten in der Kette.

struct node
{
       int data;
       struct node *next; // <-self reference
};

Alle vorherigen Antworten sind großartig. Ich wollte nur einen Einblick geben, warum eine Struktur keine Instanz ihres eigenen Typs enthalten kann (keine Referenz).

Es ist sehr wichtig zu beachten, dass Strukturen 'Wert'-Typen sind, dh sie enthalten den tatsächlichen Wert. Wenn Sie also eine Struktur deklarieren, muss der Compiler entscheiden, wie viel Speicher einer Instanz davon zugewiesen werden soll, damit er alle seine Mitglieder durchläuft und hinzufügt Erhöhen Sie den Speicher, um den Gesamtspeicher der Struktur zu ermitteln. Wenn der Compiler jedoch eine Instanz derselben Struktur im Inneren gefunden hat, ist dies ein Paradoxon (dh um zu wissen, wie viel Speicher Struktur A benötigt, müssen Sie entscheiden, wie viel Speicher erforderlich ist Struktur A dauert!).

Referenztypen sind jedoch unterschiedlich, wenn eine Struktur 'A' eine 'Referenz' auf eine Instanz ihres eigenen Typs enthält, obwohl wir noch nicht wissen, wie viel Speicher ihr zugewiesen ist, wissen wir, wie viel Speicher einem Speicher zugewiesen ist Adresse (dh die Referenz).

HTH