Answer.

Background:

Recursion has been supported in C since its inception — it naturally fits into the language's paradigm, allowing for compact solutions, especially for problems involving trees, lists, and complex decomposition algorithms.

Problem:

The main risks of using recursion include excessive stack consumption, the possibility of stack overflow, and non-obvious performance impacts (compared to iterative implementations). C does not provide a standard way to automatically control the depth of nested calls.

Solution:

Before using recursion, evaluate the maximum possible level of nesting, use tail recursion when possible (for compiler optimization), and add overflow protection, such as an explicit recursion depth counter. An alternative method is to replace recursive calls with iterative constructs for simple tasks.

Code example:

#include <stdio.h>
#define MAX_DEPTH 1000

int factorial(int n, int depth) {
    if (depth > MAX_DEPTH) {
        printf("Error: maximum recursion depth exceeded!
");
        return -1;
    }
    if (n == 0) return 1;
    return n * factorial(n - 1, depth + 1);
}

int main() {
    printf("%d
", factorial(5, 0)); // 120
    return 0;
}

Key features:

No guarantee of automatic recursion depth limitation
Recursion consumes stack, which may be limited
Tail recursion may be optimized by the compiler, but not always

Trick questions.

Will the stack be cleared if a return is executed inside a recursive function before all calls are completed?

Yes, the stack is released upon exiting the current function. No "hanging" data will remain on the stack as long as it hasn't overflowed.

Can static local variables be declared inside the body of a recursive function, and how will they behave?

Yes. Such variables will be shared among all recursive calls, and their value will be preserved between calls, which often leads to bugs if this behavior is not accounted for.

Does the C compiler affect recursion depth, and can it limit it?

The compiler does not directly limit recursion. Recursion depth is limited by the operating system's stack size or external factors.

Common mistakes and anti-patterns

Unbounded recursion without depth checking
Uninitialized or static local variables in the recursive function body
Using recursion where an iterative loop would be simpler and more efficient

Real-life example

A recursive search tree traversal was implemented without depth limitation:

Pros:

The code is concise and easy to read

Cons:

With a large tree depth, the program terminated with a stack overflow error.

In the improved version, a depth counter was introduced and switched to a stack-based traversal for large tree sizes: