samodzielna definicja struktury odwołań?

Question

Nie pisałem C przez bardzo długi czas, więc nie jestem pewien, w jaki sposób powinienem wykonywać te rodzaje rekursywnych rzeczy ... Chciałbym, aby każda komórka zawierała inną komórkę, ale dostaję błąd wzdłuż linii "pola" dziecka "ma niepełny typ". Co tam?

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

PS (Ziggy jest także wyraźnie zdezorientowany typedef: on typedefed Cell do Cell i zastanawia się, dlaczego?)

Answer 1

Wyraźnie komórka nie może zawierać inną komórkę jako staje się niekończącym się rekurencji.

Jednak komórka CAN może zawierać wskaźnik do innej komórki.

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

Answer 2

W C (w przeciwieństwie do C++, gdzie może to być możliwe, nie zaznaczone), nie można odwołać typedef że jesteś tworzenie withing samą strukturę. Trzeba użyć nazwy struktury, jak w poniższym programie testowym:

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

Chociaż to chyba o wiele bardziej skomplikowany niż ten w normie, można myśleć o nim jako kompilatora Wiedząc o struct Cell na pierwszej linii z typedef, ale nie wiedząc o tCell aż do ostatniej linii :-) Tak właśnie pamiętam tę zasadę.

Answer 3

Jest swego rodzaju odwrót to:

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

struct Cell; 
typedef struct Cell Cell; 

Jeśli zadeklarujesz to tak, że właściwie informuje kompilator, że struktura komórkowa i zwykły ol' komórki są takie same. Więc możesz używać Cell tak jak zwykle. Nadal jednak trzeba użyć struct Cell wewnątrz samej deklaracji wstępnej.

Answer 4

Z teoretycznego punktu widzenia języki mogą wspierać tylko struktury samoodniosące się, a nie struktury samozatrudnione.

Answer 5

Struktura, która zawiera odniesienie do samego siebie. Częstym zjawiskiem jest to w strukturze, która opisuje węzeł dla listy linków. Każdy węzeł potrzebuje odniesienia do następnego węzła w łańcuchu.

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

Answer 6

Znam ten post jest stary, jednak aby uzyskać efekt, którego szukasz, możesz spróbować wykonać następujące czynności:

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

W każdym z tych dwóch przypadków wymienionych w kodzie fragment powyżej, MUSISZ zadeklarować swoje dziecko Struktura komórki jako wskaźnik. Jeśli tego nie zrobisz, otrzymasz błąd "pole" dziecko "ma niekompletny typ". Powodem jest to, że "struct Cell" musi zostać zdefiniowany, aby kompilator wiedział, ile miejsca należy przydzielić, kiedy zostanie użyty.

Jeśli spróbujesz użyć "struct Cell" w definicji "struct Cell", to kompilator nie może jeszcze wiedzieć, ile miejsca ma "struct Cell". Jednak kompilator już wie, ile miejsca zajmuje wskaźnik i (z deklaracją forward) wie, że "Cell" jest typem "struct Cell" (chociaż nie wie jeszcze, jak duża jest "struct cell"). Tak więc kompilator może zdefiniować "komórkę *" wewnątrz definiowanej struktury.

Answer 7

Przejdźmy przez podstawową definicję typedef. typedef służy do definiowania aliasu do istniejącego typu danych, albo jest zdefiniowany przez użytkownika, albo wbudowany.

typedef <data_type> <alias>; 

np

typedef int scores; 

scores team1 = 99; 

Zamieszanie tutaj jest z samonośną referencyjnego, ze względu na członek danych tego samego typu, który nie jest określić wcześniej. Tak więc w standardowy sposób można napisać kod jak: -

//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; 

Ale ostatnia opcja zwiększenia jakieś dodatkowe linie i rozmowę z reguły nie chcemy robić (jesteśmy tak leniwy wiesz;)). Więc wolą Zobacz 2.

Answer 8

Innym wygodnym sposobem jest wstępnie typedef struktury, struktury z tag jak:

//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; 

Answer 9

Wszystkie poprzednie odpowiedzi są świetne, pomyślałem, aby dać wgląd w dlaczego struktura może nie zawierają instancji własnego typu (nie odniesienia).

to bardzo ważne, aby zauważyć, że struktury są typami "wartościowymi", tzn. Zawierają rzeczywistą wartość, więc kiedy deklarujesz strukturę, kompilator musi zdecydować, ile pamięci przypisać do instancji, tak że przechodzi przez wszystkie jego członkowie i sumują swoją pamięć, aby obliczyć całą pamięć struktury, ale jeśli kompilator znalazł instancję o tej samej strukturze wewnątrz, to jest to paradoks (tj. aby wiedzieć, ile pamięci A zajmuje ci A zdecyduj, ile zajmuje pamięć klasy A!).

Ale typy odniesienia są różne, jeśli struktura "A" zawiera "odwołanie" do instancji własnego typu, chociaż nie wiemy jeszcze, ile pamięci jest do niego przydzielona, ​​wiemy, ile pamięci jest przydzielone do adresu pamięci (tj. odniesienia).

HTH