Unit-6: Functions | BCA semester 1

basic types of function
In C programming, there are two basic types of functions:
Library functions: These are the built-in functions in C that are included in the C library. For example, printf, scanf, strcpy, etc. Library functions are used to perform specific tasks, such as reading from the standard input or writing to the standard output, and they return a value of specific data type.
User-defined functions: These are the functions that are defined by the user to perform specific tasks in the program. User-defined functions can either return a value or return nothing (void). To use a user-defined function, you need to write its definition and call it in the main program or in other functions.
In both cases, functions can take zero or more arguments as input and can return a value of any data type, such as int, float, char, etc. Functions are useful in breaking down complex problems into smaller and manageable tasks, and they help to increase the modularity and reusability of the code
Declaration and definition
In C programming, declaration and definition are two different concepts.
Declaration: A declaration is a statement that informs the compiler about the name, return type, and number of arguments of a function. The declaration does not provide the implementation of the function, but it tells the compiler that the function exists and can be called from other parts of the program. A declaration can be placed in a header file or in the main program.
Syntax:
return_type function_name(argument_type argument_name, argument_type argument_name, ...);
Example:
int max(int a, int b);
In this example, the declaration of the function max informs the compiler that the function takes two integer arguments and returns an integer value.
Definition: A definition is a statement that provides the implementation of a function. The definition contains the code that specifies what the function does. A definition can be placed in a source file or in the main program.
Syntax:
return_type function_name(argument_type argument_name, argument_type argument_name, ...) {
  // Function body
}
Example:
int max(int a, int b) {
  if (a > b) {
   
 return a;
  } 
else {
   
 return b;
 
   }
}
In this example, the definition of the function max implements the code that returns the maximum of two integers.
It is important to note that a function can be declared multiple times, but it must be defined only once in the program. If a function is declared in a header file, it should be defined in a source file. The declaration and definition should match exactly in terms of the return type, function name, and number and type of arguments.
function call
A function call is a statement that invokes a function and causes the code in the function definition to be executed. In a function call, you pass values to the function as arguments and the function returns a value or performs some action.
Syntax:
function_name(argument_value, argument_value, ...);
Example:
#include <stdio.h>

int max(int a, int b) {

  if (a > b) {
    return a;

  } 
else {
  
  return b;
  }
}


int main() {
  
int x = 10, y = 20;
  int result = max(x, y);
  printf("The maximum of %d and %d is %d\n", x, y, result);
  return 0;

}
In this example, the function max takes two integer arguments a and b and returns the maximum of the two. The main function calls the max function by passing x and y as arguments, and it stores the result in the result variable. Finally, it prints the result.
When a function is called, the values of the arguments are passed to the corresponding parameters in the function definition. The function performs the actions specified in its definition, and if it returns a value, that value can be stored in a variable or used in an expression. If a function does not return a value, it is considered to return void
Types of function
In C programming, there are several types of functions based on the return type and the number and type of arguments they take. Here are some of the most common types:
1.Functions with no return type and no arguments: These functions perform a task and do not return any value. The return type of such functions is void.
Example:
#include <stdio.h>

void print_message() {

  printf("Hello, World!\n");

}

int main() {
  
print_message();
  return 0;
}
2. Functions with no return type and some arguments: These functions perform a task and take one or more arguments. The return type of such functions is void.
Example:
#include <stdio.h>


void print_sum(int a, int b) {

  int sum = a + b;
  
printf("The sum of %d and %d is %d\n", a, b, sum);
}


int main() {
  
print_sum(10, 20);
  return 0;
}
3. Functions with a return type and no arguments: These functions perform a task and return a value. The return type can be any data type, such as int, float, char, etc.
Example:
#include <stdio.h>

int square(int x) {
  return x * x;

}


int main() {
  int x = 10;
  int result = square(x);
  printf("The square of %d is %d\n", x, result);

  return 0;
}
3. Functions with a return type and some arguments: These functions perform a task, take one or more arguments, and return a value. The return type can be any data type, such as int, float, char, etc.
Example:
#include <stdio.h>

int max(int a, int b) {
  if (a > b) {
  
  return a;
  } else {
    return b;
  }

}


int main() {
  int x = 10, y = 20;

  int result = max(x, y);

  printf("The maximum of %d and %d is %d\n", x, y, result);
  
return 0;

}
These are some of the most common types of functions in C programming. Functions can be combined and nested to perform complex tasks. By dividing a program into functions, you can make the code more modular, readable, and reusable
Parameter passing
In C, when a function is called, the arguments passed to the function are passed to its parameters. There are three ways to pass parameters to a function in C:
Call by value: In this method, a copy of the argument value is passed to the function. The function operates on the copy, and any changes made to the parameter within the function are not reflected in the original argument.
Example:
#include <stdio.h>

void swap(int a, int b) {
  int temp = a;
  
a = b;
  b = temp;
}


int main() {
  int x = 10, y = 20;

  printf("Before swapping: x = %d, y = %d\n", x, y);
  
swap(x, y);
  
printf("After swapping: x = %d, y = %d\n", x, y);
  
return 0;
}
Output:
Before swapping: x = 10, y = 20
After swapping: x = 10, y = 20
As you can see, the values of x and y are not swapped because the swap function operates on the copy of the argument values and not on the original values.
Call by reference: In this method, a reference to the argument value is passed to the function. The function operates on the original value, and any changes made to the parameter within the function are reflected in the original argument.
Example:
#include <stdio.h>

void swap(int *a, int *b) {
  int temp = *a;
  *a = *b;

  *b = temp;
}


int main() {
  
int x = 10, y = 20;
  printf("Before swapping: x = %d, y = %d\n", x, y);
  
swap(&x, &y);
  
printf("After swapping: x = %d, y = %d\n", x, y);
  return 0;
}
Output:
Before swapping: x = 10, y = 20
After swapping: x = 20, y = 10
In this example, the swap function takes two pointer arguments a and b, and it swaps the values pointed by these pointers. The main function passes the addresses of x and y to the swap function, and as a result, the values of x and y are swapped.
Call by address: This is similar to call by reference, but instead of using pointers, the function takes the address of the argument directly.
Example:
#include <stdio.h>


void swap(int &a, int &b) {

  int temp = a;
  a = b;
  b = temp;
}


int main() {
  
int x = 10, y = 20;

  printf("Before swapping: x = %d, y = %d\n", x, y);
  swap(x, y);
  
printf("After swapping: x = %d, y = %d\n", x, y);
  return 0;

}
Output:
Before swapping: x = 10, y = 20
After swapping: x
scope of variable
A variable’s scope refers to the region of the program where the variable can be accessed. In other words, it defines the visibility and lifetime of a variable. The scope of a variable can be classified into two types:
Local scope: A variable with local scope is defined within a function or a block of code and can only be accessed within that specific block. Once the control leaves the block, the variable and its value are destroyed.
Global scope: A variable with global scope is defined outside of any function or block of code and can be accessed by any part of the program. Global variables are created and initialized when the program starts and their values persist until the program ends.
It is important to note that the same variable name can be used in different scopes, but the value and access of each variable is independent of each other. In such cases, the variable with the local scope takes precedence over the global variable with the same name.
Storage classes
Storage classes are a way to specify the lifetime and visibility of a variable in a program. They define how the memory for a variable is allocated and how the variable can be accessed. The most common storage classes are:
1.Automatic storage class: Variables declared inside a function with no storage class specified are automatically assigned the “automatic” storage class. These variables are also called “local variables”. They are stored on the stack and are created and destroyed each time the function is called. Example:
void func() {
  
int x = 10;
  // x is an automatic variable

}
2. Register storage class: Variables declared with the “register” storage class are stored in CPU registers instead of in memory. This can increase the program’s performance, since access to CPU registers is faster than access to memory. However, the number of register variables is limited, so not all variables declared as “register” will actually be stored in a register. Example:
void func() {
  
register int x = 10;
  // x is a register variable
}
3. Static storage class: Variables declared with the “static” storage class have a scope that is limited to the function in which they are declared, but their value is preserved between function calls. In other words, they are initialized only once and their value is retained between function calls. Example:
void func() {
  
static int x = 10;
  // x is a static variable

}
4. External storage class: Variables declared outside of any function with no storage class specified are automatically assigned the “external” storage class. These variables are also called “global variables”. They can be accessed by any function in the program. Example:
int x = 10;
// x is an external variable
It is important to choose the right storage class for a variable, as it affects the performance and behavior of the program.
recursion
Recursion is a technique in computer programming where a function calls itself in order to solve a problem. A function that uses recursion is called a recursive function.
In a recursive function, the problem to be solved is divided into smaller sub-problems, and the function is called recursively on each sub-problem until a base case is reached. The base case is a stopping condition that stops the recursion.
For example, consider the problem of computing the factorial of a number. The factorial of a number n is defined as n! = n * (n-1) * (n-2) * ... * 1. To solve this problem using recursion, we can define a recursive function factorial that takes an integer n as input and returns n!. The function can be defined as follows:
int factorial(int n) {
  if (n == 0) {
    return 1;  // base case
  } else {
    return n * factorial(n-1);  // recursive call
  }
}
The function checks if the input n is equal to 0, which is the base case. If n is equal to 0, the function returns 1, which is the factorial of 0. If n is not equal to 0, the function returns n * factorial(n-1). This is the recursive call, where the function calls itself with n-1 as the input. The recursion continues until the base case is reached.
For example, to compute the factorial of 5, we can call the function as follows:
int result = factorial(5);
The function will call itself with the following inputs: factorial(5), factorial(4), factorial(3), factorial(2), factorial(1), factorial(0). When the input is factorial(0), the base case is reached and the function returns 1. The previous calls to the function return 1 * 2 * 3 * 4 * 5 = 120, which is the factorial of 5.
It is important to note that recursion can be a powerful technique, but it can also be dangerous if not used correctly. A recursive function must have a clear base case and a correct recursive step to avoid infinite recursion, which can cause a stack