Answer.

Background:

In C, it is sometimes required for one structure to "know" about another, but both structures' definitions depend on each other (mutual nesting). Therefore, it is impossible to fully define one structure before declaring the second. For this purpose, C provides forward declaration of structures.

The Problem:

Without forward declaration, the compiler does not know what type is encountered inside a structure and will issue an error about the unknown type. An error often occurs when we try to make a structure that contains another by value, not by pointer, or if we incorrectly write the syntax.

The Solution:

Forward declaration is used if you need to create a pointer to a structure without revealing its full definition. The syntax is struct A;. The full definition (struct A { ... };) can be provided later.

Code Example:

struct B; // forward declaration

struct A {
    int val;
    struct B *link;
};

struct B {
    int id;
    struct A *parent;
};

Key Features:

You can only forward declare types if they are used as pointers inside another structure.
For value nesting (not pointer), a full definition is required earlier.
Forward declaration simplifies the creation of interrelated structures in header files, preventing circular dependencies.

Trick Questions.

Can you create a field of type "another structure by value" through forward declaration?

No, forward declaration allows using the type only as a pointer; otherwise, there will be an error: the size of the type is unknown.

struct B; // ok
struct A {
    struct B b; // error: size of B is unknown
};

Where should forward declaration be placed when working with different files?

Forward declarations should be placed in the header if the structure is used only as a pointer. The full definition can be in another header or in the implementation file.

Does forward declaration affect the size of structures and proper memory allocation?

No, because C does not know the size of an "undefined" structure, and a pointer always has the same size for a given compiler, regardless of the declared type.

Typical Errors and Anti-patterns

Attempting to declare a variable or member by value of a type described only by forward declaration.
Mismatch between forward declaration and definition (name or nested types discrepancy).
Circular inclusion of header files without forward declaration leads to compilation errors.

Real-life Example

Negative Case

In the header file, both modules contained structures with each other's fields by value. The build failed with an undefined type error.

Pros:

The opportunity to think about the architecture of relationships.

Cons:

It is impossible to code such constructions without breaking referential integrity — a restructuring of the structure is necessary.

Positive Case

One of the programmers used forward declaration and pointers, minimizing unnecessary dependencies in headers. Compilation and code maintenance became easier.