How Do I Organize Code with Functions and Recursion?

After this lesson, you will be able to:

• Write C functions with a return type, parameter list, and body
• Write function prototypes above main and definitions below main
• Explain pass-by-value and why modifying a parameter does not change the caller’s variable
• Explain local variable scope across functions
• Write a recursive function with a base case and trace its execution on the call stack

The Swap That Doesn’t Swap

Here’s one of the most instructive bugs in C:

Before you read further: look at the code below and predict what it outputs. Does swap(x, y) actually swap the values? Then read the explanation.

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

int main(void)
{
    int x = 5, y = 10;
    swap(x, y);
    printf("x = %d, y = %d\n", x, y);    // x = 5, y = 10 — DIDN'T SWAP!
}

The swap worked perfectly inside the function — but x and y didn’t change. Why? Because C passes everything by value. The function got copies of x and y, swapped the copies, and threw them away.

You’ll fix this in Series 3 with pointers. But understanding why it fails teaches you how C functions actually work.

Functions from the Ground Up

Writing Functions

A C function has four parts:

return_type function_name(parameter_list)
{
    // body
    return value;
}

Example:

double calculate_average(double sum, int count)
{
    return sum / count;
}

From Java: C functions are like Java methods, minus the class. No public, no static, no this. Just the return type, name, and parameters. If you’ve written Java methods, you can write C functions.

Function Prototypes

C reads top-to-bottom. You must declare a function before calling it:

// Prototype (declaration) — goes at top of file
double calculate_average(double sum, int count);

int main(void)
{
    double avg = calculate_average(95.0, 3);    // Call — compiler knows about it
    printf("Average: %.2f\n", avg);
    return 0;
}

// Definition — goes after main
double calculate_average(double sum, int count)
{
    return sum / count;
}

Key Insight: Prototypes let you organize your code with main first (for readability) and helper functions after. The compiler just needs to know the function’s signature before it sees a call.

Pass-by-Value

When you call a function, C copies each argument into the parameter:

void double_it(int x)
{
    x = x * 2;           // Modifies the LOCAL copy
    printf("Inside: %d\n", x);   // 10
}

int main(void)
{
    int num = 5;
    double_it(num);
    printf("Outside: %d\n", num); // Still 5!
}

Key Insight: Every function parameter is a copy. Modifying a parameter inside a function does NOT affect the caller’s variable. This is why swap(x, y) doesn’t work — it swaps copies. To modify the caller’s variable, you need pointers (Series 3).

From Java: Java primitives are also pass-by-value. But Java objects are passed by reference-value — a copy of the reference. C has no objects and no implicit references. In C, if you want to modify something in another scope, you must explicitly pass its memory address with &.

void Functions

Functions that don’t return a value use void:

void print_header(void)
{
    printf("====================\n");
    printf("  Grade Report\n");
    printf("====================\n");
}

Common Pitfall: void greet() and void greet(void) are different in C! Empty parentheses () means “unspecified number of arguments” (a legacy C89 feature). (void) means “no arguments.” Always use (void) when you mean no parameters.

Scope

Variables declared inside a function are local to that function:

void function_a(void)
{
    int x = 5;            // Local to function_a
}

void function_b(void)
{
    printf("%d", x);      // ERROR: x doesn't exist here
}

The Trick: Avoid global variables. They make code harder to reason about because any function can change them at any time. Pass data through parameters and return values instead.

Introduction to Recursion

A function that calls itself:

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

Let’s trace factorial(4):

factorial(4) = 4 * factorial(3)
             = 4 * (3 * factorial(2))
             = 4 * (3 * (2 * factorial(1)))
             = 4 * (3 * (2 * 1))
             = 4 * (3 * 2)
             = 4 * 6
             = 24

Key Insight: Every recursive function needs a base case (when to stop) and a recursive case (how to get closer to the base case). Without a base case, recursion runs forever and crashes with a stack overflow.

Each call creates a new stack frame — a block of memory holding that call’s local variables. When the call returns, its frame is removed. This is the call stack, and you’ll visualize it in detail in Series 3.

Step 1: factorial(4) called       Step 2: factorial(3) called
┌─────────────────┐               ┌─────────────────┐
│ factorial(4)    │               │ factorial(3)    │
│  n = 4          │               │  n = 3          │
│  waiting...     │               │  waiting...     │
└─────────────────┘               ├─────────────────┤
                                  │ factorial(4)    │
                                  │  n = 4          │
                                  └─────────────────┘

Step 3: Base case reached         Step 4: Unwinding
┌─────────────────┐               ┌─────────────────┐
│ factorial(1)    │               │ factorial(2)    │
│  n = 1          │               │  n = 2          │
│  returns 1      │  ← base!     │  returns 2*1=2  │
├─────────────────┤               ├─────────────────┤
│ factorial(2)    │               │ factorial(3)    │
│  n = 2          │               │  n = 3          │
├─────────────────┤               ├─────────────────┤
│ factorial(3)    │               │ factorial(4)    │
│  n = 3          │               │  n = 4          │
├─────────────────┤               └─────────────────┘
│ factorial(4)    │
│  n = 4          │
└─────────────────┘

Power Function (Recursion Example)

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

printf("%.0f\n", power(2.0, 10));    // 1024

Functions Are Your Building Blocks

Functions let you break a program into manageable, reusable pieces. But the pass-by-value limitation is real — you can’t modify a caller’s variable from inside a function. Not yet.

In Series 3, you’ll learn pointers — the mechanism that lets you pass memory addresses to functions, finally making swap work. Pointers are the most important concept in C, and functions are where they become essential.

Next: input handling. You’ll learn the buffer-clearing pattern and how to build reliable input loops for your labs.

Big Picture: C doesn’t have function overloading (multiple functions with the same name but different parameters). Each function name must be unique. This is simpler than Java but means you’ll see names like print_int, print_double, print_string instead of three print methods.