What is Function in C Language with Example

 In C programming, a function is a block of code that performs a specific task and can be called or invoked from other parts of the program. Functions provide modularity, reusability, and better code organization by breaking down complex programs into smaller, manageable units. Here's a detailed explanation of functions in C along with examples:

1. Function Declaration:
   A function must be declared before it is used. The declaration specifies the function name, return type, and the types of parameters (if any) that the function accepts. It typically appears before the main function or in a header file.

   Syntax:
   ```c
   return_type function_name(parameter1_type parameter1, parameter2_type parameter2, ...);
   ```

   Example:
   ```c
   int add(int num1, int num2); // Function declaration
   ```

2. Function Definition:
   The function definition contains the actual implementation of the function. It specifies the code to be executed when the function is called.

   Syntax:
   ```c
   return_type function_name(parameter1_type parameter1, parameter2_type parameter2, ...) {
       // Code to be executed
       // Return statement (if applicable)
   }
   ```

   Example:
   ```c
   int add(int num1, int num2) { // Function definition
       int sum = num1 + num2;
       return sum;
   }
   ```

3. Function Call:
   To execute a function, it needs to be called or invoked. The function call transfers control to the function, and the specified arguments are passed to the function parameters.

   Syntax:
   ```c
   return_value = function_name(argument1, argument2, ...);
   ```

   Example:
   ```c
   int result = add(5, 3); // Function call
   ```

4. Return Statement:
   The return statement terminates the execution of a function and returns a value (if the function has a return type other than `void`). It can be used at any point within the function, and the function can have multiple return statements.

   Syntax:
   ```c
   return expression;
   ```

   Example:
   ```c
   int add(int num1, int num2) {
       int sum = num1 + num2;
       return sum; // Return the sum
   }
   ```

5. Function Parameters:
   Functions can accept input parameters, which are variables used to pass values into the function. Parameters are specified in the function declaration and definition, and their values are provided during the function call.

   Example:
   ```c
   int multiply(int num1, int num2) { // Function with parameters
       int product = num1 * num2;
       return product;
   }

   int main() {
       int result = multiply(4, 6); // Function call with arguments
       return 0;
   }
   ```

6. Function Prototype:
   A function prototype declares the function's name, return type, and parameter types without providing the actual function implementation. It is used to inform the compiler about the existence and signature of the function before it is called.

   Syntax:
   ```c
   return_type function_name(parameter1_type parameter1, parameter2_type parameter2, ...);
   ```

   Example:
   ```c
   int multiply(int num1, int num2); // Function prototype

   int main() {
       int result = multiply(4, 6); // Function call
       return 0;
   }

   int multiply(int num1, int num2) { // Function definition
       int product = num1 * num2;
       return product;
   }
   ```

Functions in C play a crucial role in modularizing code, promoting reusability, and improving code readability and maintainability. They allow complex programs to be divided into smaller, manageable units, making the code more organized and easier to understand. By encapsulating specific tasks within functions, you can create modular and efficient programs.

 

Here's an example program that demonstrates the use of functions in C:

c

#include <stdio.h>

// Function to calculate the factorial of a number
int factorial(int num) {
    int fact = 1;

    for (int i = 1; i <= num; i++) {
        fact *= i;
    }

    return fact;
}

// Function to check if a number is prime
int isPrime(int num) {
    if (num <= 1) {
        return 0;
    }

    for (int i = 2; i * i <= num; i++) {
        if (num % i == 0) {
            return 0;
        }
    }

    return 1;
}

int main() {
    int n;

    printf("Enter a positive integer: ");
    scanf("%d", &n);

    // Calculate and print the factorial of the number
    int fact = factorial(n);
    printf("Factorial of %d is %d\n", n, fact);

    // Check if the number is prime and print the result
    if (isPrime(n)) {
        printf("%d is a prime number.\n", n);
    } else {
        printf("%d is not a prime number.\n", n);
    }

    return 0;
}

In this example:

• The program defines two functions: factorial and isPrime.
• The factorial function calculates the factorial of a number by iterating from 1 to the given number and multiplying the values.
• The isPrime function checks if a number is prime by iterating from 2 to the square root of the given number and checking if any divisor is found.
• In the main function, the user is prompted to enter a positive integer.
• The factorial function is called to calculate the factorial of the entered number, and the result is printed.
• The isPrime function is called to check if the entered number is prime, and the result is printed accordingly.

Feel free to run the program and enter different numbers to see the factorial and primality results.