> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C Self-Referential Struct A self-referential struct in C is a structure definition that includes at least one member which is a pointer to the structure type itself. This construct allows a struct to reference other instances of the exact same type in memory. ## Memory Layout and Compiler Constraints A struct cannot contain an instance of itself by value. The C compiler must compute the exact memory footprint of a struct at compile time. If a struct contained itself by value, it would trigger an infinitely recursive size calculation, resulting in a compiler error. To bypass this, self-reference must be implemented using pointers. Because pointers have a fixed, architecture-defined size (e.g., 4 bytes on a 32-bit system or 8 bytes on a 64-bit system) regardless of the data type they point to, the compiler can successfully resolve the total size of the struct. ## Basic Syntax The self-referencing member must be declared using the `struct` keyword followed by the struct tag, explicitly defining it as a pointer (`*`). ```c theme={"dark"} struct Node { int payload; struct Node* link; /* Valid: Pointer to incomplete type 'struct Node' */ }; ``` ## The `typedef` Nuance A common pitfall occurs when combining self-referential structs with `typedef` aliases. In C, a `typedef` alias is not fully registered in the compiler's symbol table until the *end* of the declaration. Therefore, you cannot use the `typedef` alias inside the struct body to declare the self-referential pointer. **Invalid Syntax:** ```c theme={"dark"} typedef struct { int payload; Node* link; /* ERROR: 'Node' is not yet defined at this point */ } Node; ``` **Correct Syntax:** To resolve this, you must provide a struct tag alongside the `typedef`. The internal pointer must reference the struct tag, while external code can use the `typedef` alias. ```c theme={"dark"} typedef struct Node { int payload; struct Node* link; /* Must use 'struct Node*' internally */ } Node_t; /* External declarations can now use the alias */ Node_t instance1; Node_t instance2; instance1.link = &instance2; ``` ## Multiple Self-References A struct is not limited to a single self-referential pointer. It can contain multiple pointers to its own type, provided each is explicitly declared as a pointer to the struct tag. ```c theme={"dark"} struct MultiNode { int payload; struct MultiNode* primary_link; struct MultiNode* secondary_link; struct MultiNode* tertiary_link; }; ``` ## Forward Declaration If two distinct structs need to reference each other (mutual recursion), or if you want to abstract the struct definition, you must use a forward declaration. This informs the compiler that the struct type exists before its memory layout is fully defined. ```c theme={"dark"} /* Forward declaration */ struct State; struct Transition { int condition; struct State* target_state; }; /* Full definition */ struct State { int id; struct Transition* next_transition; }; ```

Tired of Poor C Skills? Fix That With Deep Grasping! Learn More