Functions & Recursion in C: Definitions, Calls, Scope & Recursion

TAKEAWAYS:

• A function is a reusable block of code with a name, parameters, return type, and body that performs a specific task.
• Function calls transfer control to the function, pass arguments, and return a value (if any) to the caller.
• Scope rules determine where variables are accessible: local (inside function), global (entire program), and formal parameters (inside function only).
• Recursion is a function calling itself to solve smaller subproblems, requiring a base case (stopping condition) and a recursive case (progress toward base).
• Pass-by-value copies the argument, while pass-by-reference (using pointers) modifies the original variable.
• NEB exams test function prototypes, scope conflicts, recursive logic, and debugging—practice tracing and writing both iterative and recursive solutions.

1. What is a Function?

A function is a named block of code that performs a specific task. It helps in:

• Code reusability: Write once, use many times.
• Modularity: Break large programs into smaller, manageable parts.
• Readability: Give meaningful names to functions (e.g., calculateSum() instead of main() doing everything).

Parts of a Function

return_type function_name(parameter_list) {
    // Function body
    return value; // Optional, if return_type is not void
}

• Return type: Data type of the value returned (e.g., int, float, void).
• Function name: Identifier (e.g., addNumbers).
• Parameter list: Inputs to the function (e.g., (int a, int b)).
• Function body: Statements inside {}.
• Return statement: Sends a value back to the caller (only for non-void functions).

(A labeled diagram showing the structure of a function with arrows pointing to return_type, function_name, parameters, and body.)

2. Defining and Calling Functions

Example: Adding Two Numbers

// Function definition
int add(int x, int y) {
    return x + y;
}

int main() {
    int a = 5, b = 7, sum;
    sum = add(a, b); // Function call
    printf("Sum = %d", sum); // Output: Sum = 12
    return 0;
}

Key Points:

• The function add() is defined before main() (or declared with a prototype).
• add(a, b) is a function call where a and b are arguments passed to x and y.
• The returned value (x + y) is stored in sum.

TRACE EXAMPLE: Step-by-Step Execution

flowchart TD
    A["main() starts"] --> B["a=5, b=7"]
    B --> C["sum = add(a, b)"]
    C --> D["add() called\nx=5, y=7"]
    D --> E["return 5+7=12"]
    E --> F["sum = 12 in main()"]
    F --> G["Print 'Sum = 12'"]

(Shows how control moves from main() to add() and back.)

3. Types of Functions

4. Function Prototypes

If a function is defined after main(), declare it first with a prototype:

int add(int, int); // Prototype (no body)

int main() {
    int sum = add(3, 4); // Call before definition
    return 0;
}

int add(int x, int y) { // Definition
    return x + y;
}

Why?

• Tells the compiler about the function’s name, parameters, and return type before it’s used.
• Helps catch errors early (e.g., wrong number of arguments).

5. Scope of Variables

Variables can be:

1. Local: Inside a function (accessible only there).
2. Global: Outside all functions (accessible everywhere).
3. Formal parameters: Inside a function (like local variables).

Example: Scope Conflict

int x = 10; // Global variable

void display() {
    int x = 20; // Local variable (hides global x)
    printf("Local x = %d\n", x); // Output: 20
}

int main() {
    printf("Global x = %d\n", x); // Output: 10
    display();
    return 0;
}

Output:

Global x = 10
Local x = 20

Key Rule:

• If a local variable and global variable have the same name, the local one is used inside the function.

(A diagram showing global variables in the outer box, local variables inside function boxes, and arrows showing accessibility.)

6. Passing Arguments: Call by Value vs. Call by Reference

sequenceDiagram
    participant main as main()
    participant swap as swap(int*, int*)
    main->>swap: swap(&x, &y) (x=5, y=10)
    swap->>main: *a=10, *b=5 (modifies original)
    main-->>main: x=10, y=5
    note right of main: Call by Reference
    sequenceDiagram
    participant main as main()
    participant add as add(int, int)
    main->>add: add(5, 10) (copies values)
    add-->>main: returns 15 (originals unchanged)
    note right of main: Call by Value

Example: Call by Reference (Swapping)

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

int main() {
    int x = 5, y = 10;
    swap(&x, &y); // Pass addresses
    printf("x = %d, y = %d", x, y); // Output: x = 10, y = 5
    return 0;
}

Why * and &?

• &x → Address of x.
• *a → Value at address a.

(A diagram showing two boxes: one with a copy of the value (call by value) and one with an arrow pointing to the original variable (call by reference).)

7. Recursion in C

Recursion is when a function calls itself to solve smaller instances of the same problem.

Parts of a Recursive Function

1. Base Case: Stops the recursion (prevents infinite calls).
2. Recursive Case: Calls the function again with a modified input.

Example: Factorial Using Recursion

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

int main() {
    int num = 5, result = factorial(num);
    printf("Factorial of %d = %d", num, result); // Output: 120
    return 0;
}

Trace for factorial(3):

Output: 3 * 2 * 1 = 6

Key Rules for Recursion

1. Must have a base case (otherwise, infinite recursion → stack overflow).
2. Each call should move closer to the base case (e.g., n-1 in factorial).
3. Avoid excessive recursion (slows down the program).

(A stack diagram showing calls to factorial(3), factorial(2), factorial(1), and the return values.)

8. Advantages and Disadvantages of Functions

9. Common Errors and Debugging

EXAM TIP:

• NEB often tests:
  1. Function prototypes (order of definition vs. call).
  2. Scope conflicts (global vs. local variables).
  3. Recursive logic (trace factorial(4) or fibonacci(5)).
  4. Call by value/reference (when to use * and &).
• Practice:
  • Write a function to check if a number is prime (recursive/iterative).
  • Debug a program with scope errors.
  • Convert an iterative loop to recursion (e.g., sum of first n numbers).

10. NEB-Style Questions and Solutions

Question 1: Function Definition and Call

Write a function int power(int base, int exp) to calculate base^exp using recursion. Call it in main() to print 2^3.

Solution:

#include <stdio.h>

int power(int base, int exp) {
    if (exp == 0) // Base case
        return 1;
    else
        return base * power(base, exp - 1); // Recursive case
}

int main() {
    int result = power(2, 3);
    printf("2^3 = %d", result); // Output: 8
    return 0;
}

Question 2: Scope and Global Variables

What will the following program print?

int x = 5;
void display() {
    int x = 10;
    printf("%d ", x);
}
int main() {
    display();
    printf("%d", x);
    return 0;
}

Answer:

10 5

Explanation:

• Inside display(), x is local (10).
• In main(), x is global (5).

Question 3: Call by Value vs. Reference

Modify the following program to swap two numbers using call by reference:

void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}
int main() {
    int x = 5, y = 10;
    swap(x, y);
    printf("x = %d, y = %d", x, y); // Output: x = 5, y = 10 (no swap)
    return 0;
}

Solution:

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}
int main() {
    int x = 5, y = 10;
    swap(&x, &y); // Pass addresses
    printf("x = %d, y = %d", x, y); // Output: x = 10, y = 5
    return 0;
}

Question 4: Recursive Function

Write a recursive function to print numbers from n to 1. Solution:

void printNumbers(int n) {
    if (n == 0) // Base case
        return;
    printf("%d ", n);
    printNumbers(n - 1); // Recursive call
}
int main() {
    printNumbers(5); // Output: 5 4 3 2 1
    return 0;
}

11. Summary Table: Key Concepts

12. Final Tips for NEB Exam

1. Always declare functions before main() (or use prototypes) to avoid errors.
2. Trace recursive functions step-by-step (NEB loves this!).
3. Watch out for scope conflicts—rename variables if needed.
4. Use * and & correctly for call by reference.
5. Practice writing both iterative and recursive solutions (e.g., factorial, Fibonacci).

(A checklist with icons for: prototypes, scope, recursion trace, call by reference, debugging.)