Function

What is a Function?

In programming, a function is like a recipe. It’s a set of instructions that performs a specific task when called. Functions are used to break down a program into smaller, manageable parts, making it easier to understand and maintain.

Anatomy of a Function in C

In C programming, a function typically consists of:

Return Type: It specifies the type of value the function will give back after it finishes its task. For example, int, float, void (when the function doesn’t return anything), etc.
Function Name: A unique name that identifies the function.
Parameters (if any): These are like ingredients for the recipe. They are optional and allow the function to receive information needed to perform its task.
Function Body: This is where the instructions or code for the function’s task are written.

Creating a Function

Let’s create a simple function named addNumbers that adds two integers:

int addNumbers(int num1, int num2) {
    int sum = num1 + num2;
    return sum;
}

Here’s a breakdown of this function:

int before addNumbers indicates that this function will return an integer value.
addNumbers is the name of the function.
(int num1, int num2) are the parameters the function expects (two integers named num1 and num2).
Inside {}, the code calculates the sum of num1 and num2 and stores it in the sum variable.
return sum; sends the calculated sum back as the result of the function.

Using a Function

You can use the addNumbers function by calling it from your main program:

#include <stdio.h>
 
int addNumbers(int num1, int num2); // Function prototype
 
int main() {
    int result = addNumbers(10, 5); // Calling the function
    printf("Sum: %d\n", result);
    return 0;
}
 
int addNumbers(int num1, int num2) {
    int sum = num1 + num2;
    return sum;
}

int addNumbers(int num1, int num2); at the top is called a function prototype. It informs the compiler about the function before using it in the main function.
int result = addNumbers(10, 5); is the function call. It sends 10 and 5 as arguments to addNumbers, and the returned sum is stored in the result variable.
printf("Sum: %d\n", result); prints the calculated sum.

Actual Parameters

In programming, actual parameters are the values or variables passed to a function when it is called. These values provide the actual data that the function will operate on. When you call a function, you provide actual parameters, and these values are received by the function’s formal parameters.

Formal Parameters

Formal parameters are the variables listed in a function’s definition. They act as placeholders for the values that will be passed into the function when it is called. These parameters are declared in the function signature and represent the data the function expects to receive in order to perform its task.

Let’s take the example of the addNumbers function from earlier:

int addNumbers(int num1, int num2) 
{
    int sum = num1 + num2;
    return sum;
}

Here, num1 and num2 are the formal parameters. When you call this function with addNumbers(10, 5), 10 and 5 are the actual parameters that will be received by num1 and num2, respectively, inside the function.

Recursion

Recursion is a programming technique where a function calls itself to solve a problem by breaking it down into smaller, similar subproblems. In essence, it’s like a function that uses its own result to solve instances of the same problem but with reduced complexity.

Example: Factorial Calculation using Recursion

Consider calculating the factorial of a number:

int factorial(int n) 
{
    if (n <= 1) {
        return 1;
    }
    else {
        return n * factorial(n - 1); // Recursive call
    }
}

In this example, factorial is a recursive function that calculates the factorial of a number n. If n is 1 or less, it returns 1. Otherwise, it multiplies n with the factorial of n - 1. This function keeps calling itself with a smaller number until it reaches the base case (n <= 1), and then it starts returning values back up the chain to get the final result.

Recursion is useful for solving problems where a task can be divided into smaller tasks of the same kind. However, it’s essential to have a base case (a condition where the function stops calling itself) to avoid infinite recursion.

🪴 Quartz 4.0

Explorer