Unit 7: Functions – Definitions, Parameters, Recursion & Function Pointers

Function Basics

In C, a function is a named block of code that performs a specific task and may return a value. The general syntax is:

return_type function_name(parameter_list) {
    /* body */
}

Functions promote modularity, readability, and maintainability. They also enable abstraction: callers need not know the internal workings, only the interface.

Key Terminology

Function Declaration and Prototype

A prototype informs the compiler about a function’s return type and parameter types before its actual definition. It allows type checking of arguments at compile time.

int add(int a, int b);   /* Prototype */

If a prototype is omitted, the compiler assumes an implicit declaration (old C), which can lead to errors. Modern C (C99 onward) requires prototypes for all functions.

Placement

• Header files (.h) typically contain prototypes for functions that are shared across multiple source files.
• Source files (.c) contain the actual definitions.

Function Definition

A function definition provides the body. Example:

int add(int a, int b) {
    return a + b;
}

The compiler checks that the return type matches the prototype. If the function returns void, no value is returned.

Example: Swapping Two Integers Using Call‑by‑Reference

void swap(int *x, int *y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

Call site:

int main(void) {
    int a = 5, b = 10;
    swap(&a, &b);   /* Pass addresses */
    printf("%d %d\n", a, b);  /* 10 5 */
}

Return Types

Returning a Pointer to a Static Variable

int *counter(void) {
    static int count = 0;   /* Static: persists across calls */
    return &count;          /* Safe to return address */
}

Returning a pointer to a local (automatic) variable is unsafe because the variable’s lifetime ends when the function returns.

Parameter Passing

C uses pass‑by‑value: the function receives copies of the arguments. To modify the caller’s variables, pointers are used.

Pass‑by‑Value vs Pass‑by‑Reference

Example Trace: Recursive Factorial

int factorial(int n) {
    if (n <= 1) return 1;          /* Base case */
    return n * factorial(n - 1);   /* Recursive call */
}

Trace for factorial(4):

factorial(4)
  -> 4 * factorial(3)
        -> 3 * factorial(2)
              -> 2 * factorial(1)
                    -> 1   (base case)
              -> 2 * 1 = 2
        -> 3 * 2 = 6
  -> 4 * 6 = 24

Result: 24.

Recursion

Recursion is a technique where a function calls itself. It is powerful for problems naturally defined in terms of smaller sub‑problems (e.g., factorial, Fibonacci, tree traversal).

Requirements

1. Base case – stops recursion.
2. Recursive case – reduces the problem size.

Common Pitfalls

• Infinite recursion: missing or incorrect base case.
• Stack overflow: too deep recursion.
• Redundant calculations: e.g., naive Fibonacci leads to exponential time.

Optimized Fibonacci Using Memoization

int fib(int n, int *memo) {
    if (n <= 1) return n;
    if (memo[n] != -1) return memo[n];
    memo[n] = fib(n-1, memo) + fib(n-2, memo);
    return memo[n];
}

Function Pointers

A function pointer stores the address of a function and can be invoked indirectly. Syntax:

return_type (*ptr_name)(parameter_types);

Declaration and Assignment

int add(int a, int b) { return a + b; }
int (*func_ptr)(int, int) = add;   /* Assign address of add */

Invocation

int result = func_ptr(3, 4);   /* Calls add(3,4) */

Use Cases

• Callbacks: e.g., qsort uses a comparison function pointer.
• Dynamic dispatch: selecting behavior at runtime.
• Event handling: GUI libraries pass function pointers as handlers.

Example: Sorting with qsort

int cmp_int(const void *a, const void *b) {
    int ia = *(const int *)a;
    int ib = *(const int *)b;
    return (ia > ib) - (ia < ib);
}

int main(void) {
    int arr[] = {5, 2, 9, 1};
    qsort(arr, 4, sizeof(int), cmp_int);
}

Static and External Functions

Static functions prevent name clashes and encapsulate helper routines.

Library vs User‑Defined Functions

Advantages of Library Functions

• Optimized: often highly efficient.
• Well‑tested: reliability and portability.

Disadvantages

• Opaque: internal workings hidden.
• Limited flexibility: may not fit niche requirements.

Common Pitfalls and Best Practices

Summary Table

Exam tip

• Understand the difference between prototype, definition, and declaration.
• Be able to write a function that swaps two integers using pointers.
• Trace recursive calls and identify base cases.
• Explain function pointers and give a simple callback example.
• Distinguish library functions from user‑defined ones and discuss advantages.
• Practice writing prototypes in header files and definitions in source files.

Focus on clarity and correct syntax; exam questions often test your ability to write concise, error‑free code snippets.