definizione di struttura autoreferenziale?

Non scrivo C da molto tempo, e quindi non sono sicuro di come dovrei fare questo tipo di cose ricorsive ... Vorrei che ogni cella contenesse un'altra cella, ma ho un errore lungo il le righe di "campo" figlio "hanno tipo incompleto". Che cosa succede?

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

Chiaramente una cella non può contenere un'altra cella in quanto diventa una ricorsione infinita.

Tuttavia, una cella può contenere un puntatore a un'altra cella.

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

In C, non puoi fare riferimento al typedef che stai creando all'interno della struttura stessa. Devi usare il nome della struttura, come nel seguente programma di test:

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

Anche se è probabilmente molto più complicato di questo nello standard, puoi pensarlo come il compilatore che conosce struct Cellla prima riga typedefma che non conosce tCellfino all'ultima riga :-) È così che ricordo quella regola.

Dal punto di vista teorico, le lingue possono supportare solo strutture autoreferenziali e non strutture auto inclusive.

C'è un modo per aggirare questo:

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

struct Cell;
typedef struct Cell Cell;

Se lo dichiari in questo modo, dice correttamente al compilatore che struct Cell e plain-cell sono uguali. Quindi puoi usare Cell come al solito. Devo comunque usare struct Cell all'interno della stessa dichiarazione iniziale.

So che questo post è vecchio, tuttavia, per ottenere l'effetto che stai cercando, potresti provare quanto segue:

#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 uno dei due casi menzionati nel frammento di codice sopra, DEVI dichiarare la struttura della tua cella figlio come puntatore. In caso contrario, verrà visualizzato l'errore "campo 'figlio" con tipo incompleto ". Il motivo è che "struct Cell" deve essere definito affinché il compilatore sappia quanto spazio allocare quando viene utilizzato.

Se si tenta di utilizzare "Struct Cell" all'interno della definizione di "Struct Cell", il compilatore non può ancora sapere quanto spazio "cell Cell" dovrebbe occupare. Tuttavia, il compilatore sa già quanto spazio occupa un puntatore e (con la dichiarazione in avanti) sa che "Cell" è un tipo di "struct Cell" (anche se non sa ancora quanto sia grande una "struct Cell" ). Quindi, il compilatore può definire una "cella *" all'interno della struttura che viene definita.

Passiamo attraverso la definizione di base di typedef. typedef usa per definire un alias per un tipo di dati esistente sia esso definito dall'utente o integrato.

typedef <data_type> <alias>;

per esempio

typedef int scores;

scores team1 = 99;

La confusione qui è con la struttura autoreferenziale, a causa di un membro dello stesso tipo di dati che non è stato definito in precedenza. Quindi in modo standard puoi scrivere il tuo codice come: -

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

Ma l'ultima opzione aumenta alcune righe e parole extra che di solito non vogliamo fare (siamo così pigri che sai;)). Quindi preferisci Visualizza 2.

Un altro metodo conveniente è quello di pre-scrivere la struttura con, tag struttura come:

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

Una struttura che contiene un riferimento a se stessa. Un evento comune di questo in una struttura che descrive un nodo per un elenco di collegamenti. Ogni nodo ha bisogno di un riferimento al nodo successivo nella catena.

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

Tutte le risposte precedenti sono fantastiche, ho solo pensato di dare un'idea del perché una struttura non può contenere un'istanza del suo tipo (non un riferimento).

è molto importante notare che le strutture sono tipi di "valore", ovvero contengono il valore effettivo, quindi quando si dichiara una struttura il compilatore deve decidere la quantità di memoria da allocare a un'istanza di essa, quindi passa attraverso tutti i suoi membri e aggiunge la loro memoria per capire la memoria complessiva della struttura, ma se il compilatore ha trovato un'istanza della stessa struttura all'interno, allora questo è un paradosso (cioè per sapere quanta memoria A impiega devi decidere quanta memoria la struttura A prende!).

Ma i tipi di riferimento sono diversi, se una struttura 'A' contiene un 'riferimento' a un'istanza del proprio tipo, anche se non sappiamo ancora quanta memoria è allocata ad essa, sappiamo quanta memoria è allocata in una memoria indirizzo (cioè il riferimento).

HTH