Return Type and void Functions

1. Return Type:
   • A function can return a value to the calling function. The data type of the returned value must match the return type declared for the function.

   Example:

   int multiply(int x, int y) {
   return x * y;
   }
2. void Functions:
   • A function with a void return type does not return any value. It simply performs an action, such as printing to the screen or modifying variables.

   Example:

   void printMessage() {
   printf(“Hello, World!\n”);
   }

   iFacultynt main() {
   printMessage(); // No return value, just prints a message
   return 0;
   }

   Parameters: Pass by Value vs. Pass by Reference

   1. Pass by Value:
      • When a function is called, the actual values of the arguments are copied into the function’s parameters. The function works on these copies, and changes made inside the function do not affect the original variables.

      Example:

      void changeValue(int x) {
      x = 100; // This only modifies the local copy
      }

      int main() {
      int num = 5;
      changeValue(num);
      printf(“num = %d\n”, num); // Output will still be 5
      return 0;
      }

      Pass by Reference (using Pointers):

   2. • To modify the original value of a variable inside a function, you pass its memory address using pointers. Changes made inside the function will affect the original variable.

      Example:

      void changeValue(int *x) {
      *x = 100; // Modifies the original variable through the pointer
      }

      int main() {
      int num = 5;
      changeValue(&num); // Pass the address of num
      printf(“num = %d\n”, num); // Output will be 100
      return 0;
      }

      Recursive Functions

      A recursive function is a function that calls itself, either directly or indirectly. Recursion is particularly useful for problems that can be broken down into similar sub-problems.

      Example: Factorial Calculation Using Recursion

      #include <stdio.h>

      // Recursive function to calculate factorial
      int factorial(int n) {
      if (n == 0) {
      return 1;
      } else {
      return n * factorial(n – 1);
      }
      }

      int main() {
      int num = 5;
      printf(“Factorial of %d is %d\n”, num, factorial(num));
      return 0;
      }

      • Explanation: The factorial() function calls itself recursively until the base case (n == 0) is reached.

      Output:

      Factorial of 5 is 120

      Library Functions

      C comes with a rich set of library functions that are predefined and can be used to perform standard operations. These functions are part of header files, which must be included at the beginning of the program.

      Common Library Functions:

      1. printf(): Prints formatted output to the screen.
      2. scanf(): Reads input from the user.
      3. strlen(): Returns the length of a string.
      4. sqrt(): Calculates the square root of a number.
      5. strcmp(): Compares two strings.

      ---

      Advantages of Functions

      1. Modularization: Functions allow complex tasks to be broken into smaller parts.
      2. Reusability: Once a function is defined, it can be called from multiple parts of a program or even from other programs.
      3. Maintainability: Functions help keep the program code organized, making it easier to maintain.
      4. Abstraction: Functions hide the complexity of their implementation and provide a simple interface.

      4.2 Function prototype, call and definition

      In C programming, functions play a crucial role in organizing and reusing code. To understand functions fully, it’s essential to know about the function prototype, function call, and function definition.

1. Function Prototype

A function prototype is a declaration of a function that informs the compiler about the function’s name, return type, and parameters. It is typically placed at the beginning of the program (before the main() function) or in a header file, allowing the function to be called before its actual definition appears.

• Purpose: The prototype ensures that the compiler knows the function’s details before it is used. This allows the function to be called anywhere in the code, even if the definition comes later.

Syntax of a Function Prototype

• return_type: Data type of the value the function returns (e.g., int, float, void).
• function_name: A meaningful name that represents what the function does.
• parameter_type: The data types of the parameters the function will accept.

Example of a Function Prototype

2. Function Definition

A function definition provides the actual implementation of the function. It includes the logic to perform the task for which the function is designed. The function definition consists of the return type, function name, parameter list, and function body (code enclosed in {}).

Syntax of a Function Definition

• return_type: Specifies the data type of the value the function will return.
• function_name: The name of the function (same as the one in the prototype).
• parameter_list: Specifies the list of parameters with their data types and variable names.
• Function body: The block of code that contains the logic of the function.

Example of a Function Definition

In this example:

• The function add takes two integers (a and b) as arguments and returns their sum.
• The return type is int, meaning it returns an integer value.

3. Function Call

A function call is how a function is executed or invoked. When a function is called, the program control is transferred to the function, and the arguments (if any) are passed to it. The function performs its task, and then control is returned to the point where the function was called.

Syntax of a Function Call

• function_name: The name of the function you are calling.
• arguments: The actual values (or variables) passed to the function parameters.

Example of a Function Call

In this example:

• The function add is called with 5 and 3 as arguments.
• The function returns the value 8, which is assigned to the variable result.

Example: Comparing Both Methods

• Explanation: callByValue() does not change a in main() because it only works with a copy. callByReference() changes b in main() because it works directly with the original variable.

4.5 Recursion

Recursion is a programming technique where a function calls itself to solve a problem. It’s a powerful tool for breaking down complex problems into simpler ones and is often used for tasks that can be naturally divided into similar sub-tasks.

Key Concepts of Recursion

1. Base Case: The condition under which the recursion stops. It prevents infinite recursion by providing a simple case that can be solved directly.
2. Recursive Case: The part of the function where it calls itself with a different argument, gradually working towards the base case.

How Recursion Works

1. Function Calls Itself: In each recursive call, the function works on a smaller or simpler subset of the problem.
2. Base Case Handling: Once the function reaches the base case, it returns a value without making further recursive calls.
3. Unwinding: After reaching the base case, the function returns values back through the chain of recursive calls, completing the computation.

Example of Recursion: Factorial Function

The factorial of a number $n$ (denoted $n!$) is the product of all positive integers less than or equal to $n$. The factorial can be defined recursively:

• Base Case: $0!=1$ (or $1!=1$)
• Recursive Case: $n!=n\times (n-1)!$

Code Example:

Explanation:

• The factorial() function calls itself with n - 1 until it reaches the base case where n is 0.
• The results are multiplied and returned back through the chain of calls.

Example of Recursion: Fibonacci Sequence

The Fibonacci sequence is another classic example of recursion. Each number in the sequence is the sum of the two preceding ones:

• Base Cases: $F(0)=0$, $F(1)=1$
• Recursive Case: $F(n)=F(n-1)+F(n-2)$

Code Example:

Explanation:

• The fibonacci() function computes the Fibonacci number by calling itself with n - 1 and n - 2.
• The results are summed and returned through the chain of recursive calls.

Advantages and Disadvantages of Recursion

Advantages:

1. Simplicity: Recursion can simplify the code for problems that have a natural recursive structure (e.g., tree traversals, factorial calculation).
2. Readability: Recursive solutions are often more readable and closer to the mathematical definition of the problem.

Disadvantages:

1. Performance: Recursive functions can be less efficient than iterative solutions due to overhead from function calls and stack usage.
2. Stack Overflow: Deep recursion can lead to stack overflow errors if the recursion depth is too large or if the base case is not properly defined.

Tail Recursion

Tail Recursion is a special case of recursion where the recursive call is the last statement in the function. Some compilers optimize tail-recursive functions to reduce the function call overhead.

Example of Tail Recursion:

Explanation:

• The factorialHelper() function performs the recursive calculation in a tail-recursive manner, with the final result being computed directly without additional function call overhead