## Recursions & Recursive Functions in C++

Recursion is a powerful programming technique in which a function calls itself to solve a problem. In C++, recursion is implemented using recursive functions. A recursive function is a function that calls itself, either directly or indirectly.

### Anatomy of a Recursive Function

A recursive function has two parts: the base case and the recursive case. The base case is the condition that terminates the recursion. The recursive case is the condition that calls the function again.

Here’s a simple example of a recursive function that calculates the factorial of a number:

```
int factorial(int n) {
if (n == 0) { // Base case
return 1;
} else { // Recursive case
return n * factorial(n - 1);
}
}
```

C++In this example, the base case is when `n`

is equal to 0. When `n`

is 0, the function returns 1, which terminates the recursion. The recursive case is when `n`

is greater than 0. In this case, the function multiplies `n`

by the factorial of `n-1`

, which is calculated using a recursive call to the `factorial`

function.

### Understanding Recursion

Recursion can be difficult to understand at first, but it’s a powerful tool for solving complex problems. When you call a recursive function, the function creates a new instance of itself on the stack. Each instance of the function has its own set of local variables and parameters.

As the recursion continues, each new instance of the function is added to the stack. When the base case is reached, the function returns the result to the previous instance of the function on the stack. This continues until the original function call is completed and the final result is returned.

### Example: Fibonacci Sequence

Another classic example of a recursive function is the calculation of the Fibonacci sequence. The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones, starting from 0 and 1.

Here’s an example of a recursive function that calculates the nth number in the Fibonacci sequence:

```
int fibonacci(int n) {
if (n <= 1) { // Base case
return n;
} else { // Recursive case
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
```

C++In this example, the base case is when `n`

is less than or equal to 1. When `n`

is 0 or 1, the function returns `n`

, which terminates the recursion. The recursive case is when `n`

is greater than 1. In this case, the function calculates the nth number in the sequence by adding the previous two numbers, which are calculated using recursive calls to the `fibonacci`

function.

### Conclusion

Recursion is a powerful technique for solving complex problems in programming. Recursive functions can be difficult to understand at first, but with practice, they can become a valuable tool in your programming arsenal. When using recursion, it’s important to remember the base case and the recursive case, and to make sure that the recursion eventually terminates.