A user-defined function is a block of code written by the programmer to perform a specific task, which can be reused throughout the program. It divides a large program into smaller, manageable modules.

General Syntax

c
return_type function_name(parameter_list) {
// Local variable declarations
// Executable statements
return value;
}

Components of a Function Definition

1. Return Type: Specifies the data type of the value the function returns to the caller (e.g., int, float, void).
2. Function Name: A unique identifier used to call the function.
3. Parameter List: A list of variables (with types) that accept values passed from the calling function. It is enclosed in parentheses.
4. Function Body: The block of code enclosed in braces { } that defines the logic/task.
5. Return Statement: Used to terminate the function and pass the result back to the calling environment (optional for void functions).

A Function Prototype is a declaration statement that tells the compiler about a function's name, its return type, and the number and data types of its parameters before the function is actually defined or called.

Syntax

return_type function_name(type1 arg1, type2 arg2, ...);

Why is it necessary?

1. Compiler Validation: It allows the compiler to check if the function is being called correctly (correct number and type of arguments).
2. Type Conversion: It enables the compiler to perform implicit type conversion if the arguments passed do not exactly match the parameters but are compatible.
3. Top-Down Approach: It allows functions to be defined anywhere in the code (even after the main function) while still being callable from main.

Call by Value vs Call by Reference

Examples

1. Call by Value:
c
void modify(int x) {
x = 100; // Changes copy only
}
// In main, if a=10, modify(a) leaves a as 10.

2. Call by Reference:
c
void modify(int x) {
x = 100; // Changes value at address
}
// In main, if a=10, modify(&a) changes a to 100.

To swap two numbers using call by reference, we must pass the addresses of the variables to the function and use pointers to dereference and swap the values.

Program

c

include <stdio.h>

// Function Declaration
void swap(int a, int b);

int main() {
int num1, num2;

printf("Enter two numbers: ");
scanf("%d %d", &num1, &num2);

printf("Before Swapping: num1 = %d, num2 = %d

", num1, num2);

// Passing addresses of num1 and num2
swap(&num1, &num2);

printf("After Swapping: num1 = %d, num2 = %d

", num1, num2);
return 0;
}

// Function Definition
void swap(int a, int b) {
int temp;
temp = a; // Store value at address a into temp
a = b; // Copy value at address b to address a
b = temp; // Copy temp to address b
}

Actual Arguments and Formal Parameters refer to data transfer during a function call.

Actual Arguments

• These are the variables or values passed to the function during the function call in the calling function (e.g., inside main).
• Example: In add(a, b);, a and b are actual arguments.

Formal Parameters

• These are the variables declared in the function definition header that receive values from the actual arguments.
• They act as placeholders or local variables within the called function.
• Example: In void add(int x, int y) { ... }, x and y are formal parameters.

Key Difference: The Actual Arguments provide the input, while the Formal Parameters process that input within the function scope.

The <math.h> header file contains standard mathematical functions. Common examples include:

1. sqrt(double x):

   • Returns the square root of .
   • Example: sqrt(16.0) returns 4.0.

2. pow(double base, double exp):

   • Returns the result of base raised to the power of exp ().
   • Example: pow(2.0, 3.0) returns 8.0.

3. ceil(double x):

   • Returns the smallest integer value greater than or equal to (rounds up).
   • Example: ceil(4.2) returns 5.0.

4. floor(double x):

   • Returns the largest integer value less than or equal to (rounds down).
   • Example: floor(4.9) returns 4.0.

5. abs(int x) (found in stdlib.h usually, but fabs is in math.h):

   • fabs(double x) returns the absolute value of a floating-point number.
   • Example: fabs(-5.5) returns 5.5.

Recursion is a programming technique where a function calls itself directly or indirectly to solve a problem. The problem is solved by breaking it down into smaller instances of the same problem.

Essential Conditions

1. Base Case (Termination Condition):

   • There must be at least one condition where the function does not call itself.
   • This stops the recursion chain and prevents an infinite loop (stack overflow).
   • Example: In factorial calculation, if (n == 0) return 1;.

2. Recursive Case:

   • The part of the function where it calls itself.
   • The recursive call must move the problem closer to the base case (e.g., reducing the input size).
   • Example: return n * factorial(n - 1);.

Mathematical Logic

The factorial of a non-negative integer , denoted by , is defined as:

C Program Segment

c

include <stdio.h>

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

int main() {
int n = 5;
printf("Factorial of %d is %ld", n, factorial(n));
return 0;
}

Execution Trace for n=3:

1. factorial(3) calls 3 * factorial(2)
2. factorial(2) calls 2 * factorial(1)
3. factorial(1) calls 1 * factorial(0)
4. factorial(0) returns 1
5. Unwinding: .

Recursion vs Iteration

The Fibonacci sequence is defined as:

C Function

c
int fibonacci(int n) {
// Base Cases
if (n == 0) {
return 0;
}
else if (n == 1) {
return 1;
}
// Recursive Step
else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}

Note: While this demonstrates recursion, it is inefficient for large due to repeated calculations of the same sub-problems.

Scope determines the region of the program where a variable is visible and can be accessed.

Local Scope

• Definition: Variables defined inside a function or a block { }.
• Visibility: Accessible only within that specific function or block.
• Lifetime: Created when control enters the block and destroyed when control exits.

Global Scope

• Definition: Variables defined outside of all functions (usually at the top of the program).
• Visibility: Accessible by all functions in the program (after the declaration point).
• Lifetime: Exists for the entire duration of the program execution.

Example:
c
int globalVar = 10; // Global Scope

void func() {
int localVar = 5; // Local Scope
// Can access globalVar here
}
// Cannot access localVar here

Storage Classes in C define the following attributes of a variable:

1. Scope: Where the variable is available.
2. Visibility: Who can see the variable.
3. Lifetime: How long the variable stays in memory.
4. Storage Place: Where the variable is stored (Stack, CPU Register, Data Segment).
5. Default Initial Value: What the value is if not initialized.

List of Storage Classes:

1. auto (Automatic)
2. register (Register)
3. static (Static)
4. extern (External)

The auto (automatic) storage class is the default for all local variables.

• Keyword: auto (optional, rarely written).
• Storage Location: Stack memory.
• Scope: Local. Only within the function or block { } where it is defined.
• Lifetime: Exists only while the control is within the block. It is destroyed upon exit.
• Default Initial Value: Garbage value (unpredictable) if not manually initialized.

Example:
c
void function() {
auto int x; // same as int x;
// x has garbage value here
}

The extern (external) storage class is used to declare a global variable or function that is defined in another file or another part of the same file.

• Keyword: extern.
• Storage Location: Data segment (RAM).
• Scope: Global. Visible to all functions in the program.
• Lifetime: Throughout the program execution.
• Default Initial Value: Zero.

Usage across files

It tells the compiler, "The variable is not defined here, but it exists somewhere else."

File1.c
c
int count = 10; // Definition

File2.c
c
extern int count; // Declaration referring to File1
void printCount() {
printf("%d", count); // Prints 10
}

The static storage class preserves the value of a variable even after the variable's scope has been exited.

• Keyword: static.
• Storage Location: Data segment.
• Default Value: Zero.

Static Local Variable vs Standard Local (auto) Variable

1. Lifetime:
   • auto: Created on entry, destroyed on exit.
   • static: Created once (first call), persists between function calls until the program ends.
2. Initialization:
   • auto: Re-initialized every time the function is called.
   • static: Initialized only once.

Example:
c
void counter() {
static int count = 0;
count++;
printf("%d ", count);
}
// Calling counter() 3 times prints: 1 2 3
// If 'count' was 'auto', it would print: 1 1 1

The register storage class is a request to the compiler to store the variable in a CPU Register instead of RAM (memory) for faster access.

• Purpose: Used for frequently accessed variables (e.g., loop counters) to improve execution speed.
• Scope & Lifetime: Same as auto (Local scope, block lifetime).
• Default Value: Garbage value.

Limitations

1. No Address Operator (&): You cannot obtain the address of a register variable (e.g., &x is illegal) because registers do not have memory addresses.
2. Hardware Constraints: The number of CPU registers is limited. If no register is available, the compiler treats it as auto.
3. Size: Generally, only variables fitting the register size (like int, char, or pointers) can be stored.

Comparison of Storage Classes

Note: static can also have global scope if defined outside a function (restricted to that specific file), but the table refers to the common usage of internal static variables compared to auto.

To calculate recursively:

• Base Case: If , return 1.
• Recursive Case: .

C Code

c

include <stdio.h>

double power(double base, int exp) {
if (exp == 0)
return 1;
else
return base * power(base, exp - 1);
}

int main() {
double base = 2.0;
int exp = 3;
printf("%.2lf to the power %d is %.2lf", base, exp, power(base, exp));
return 0;
}

Output

2 2
3 2

Explanation

1. Variable y (auto): It is a standard local variable. Every time fun() is called, y is re-created and initialized to 1. It increments to 2, prints, and is destroyed.

   • Call 1: .
   • Call 2: .

2. Variable x (static): It is initialized to 1 only once when the program starts. It retains its value between function calls.

   • Call 1: x starts at 1, increments to 2. Prints 2.
   • Call 2: x retains the value 2, increments to 3. Prints 3.

When a function is called, the system allocates a block of memory on the Stack known as a Stack Frame or Activation Record.

Contents of a Stack Frame:

1. Return Address: Where control should go after the function finishes.
2. Parameters: Values passed from the calling function (Actual arguments copied to Formal parameters).
3. Local Variables: Variables declared inside the function.

Mechanism:

1. Push: When main calls func, a frame for func is pushed onto the stack on top of main's frame.
2. Execution: The CPU executes func using the variables in this top frame.
3. Pop: When func returns, its frame is popped (removed), releasing memory, and control returns to the address stored in the Return Address field, resuming main.