Answer.

The C language does not support nested functions at the ANSI/ISO standard level. Historically, C was designed as a compact language, close to hardware, where functions existed at the top level of the translation unit (file). Unlike languages like Pascal, C does not allow declaring a function inside another function purely syntactically.

The problem that programmers face: often there is a desire to use local helper sub-functions, visible only within one function, to encapsulate logic or avoid code duplication. Built-in support for nesting would reduce scope and make the code more modular.

One popular solution is to use static functions at the file level, or to pass function pointers to external functions, or to simulate nesting through structures with callback functions. If "closures" of context are needed, structures with pointers to data (analogous to closure) can be used.

Example of simulating a "local" function through pointer passing:

#include <stdio.h>

static int helper(int x) { return x * x; }

void myFunction(void) {
    printf("Square of number 5: %d
", helper(5));
}

Key features:

In C, nested functions are absent at the standard level.
One can use static functions or closures via structures for such scenarios.
Some compilers (like GCC) support nested functions as an extension, but this reduces portability.

Trick questions.

Can you define an inner function inside another function in standard C and call it?

No. In the C language (ANSI/ISO standard), you cannot declare a function inside another function. Attempting this will result in a compilation error. Some non-standard extensions (like those in GCC) allow this, but such programs will not be portable.

Can static functions fully replace nested ones in terms of meaning and safety?

Static functions restrict scope to the file function, but not to the block function. This means static functions are accessible from any code in the same file, which does not guarantee complete encapsulation as with true nested functions.

Can "closures" be implemented in nested functions in pure C?

No, there is no direct support for that. However, one can use structures containing a pointer to data and a function, which approximates closure behavior:

typedef struct {
    int context;
    int (*func)(int, int);
} closure;

int add(int a, int b) { return a + b; }

closure cl = { .context = 5, .func = add };

Typical mistakes and anti-patterns

Declaring a function inside another function in ANSI C (compilation error).
Using non-standard extensions, losing portability.
Misuse of static functions for local code.

Real life example

Negative case

A developer uses the GCC extension - declares inner functions in the project, after which the code does not compile on MSVC and other compilers.

Pros:

Compactness and convenience of local functions.

Cons:

Non-portability, difficulty in maintenance, inability to reuse code on another compiler.

Positive case

A developer restricts the scope of all helper functions to static, uses a structure to pass context.