User-defined Functions

Programming Language & Its Applications — Introduction to C Programming, NEC licence examination syllabus (Nepal Engineering Council).

User-Defined Functions: breaking a program into pieces

A function is a contract: given these inputs, produce this output.

A 500-line main() is unmaintainable and untestable. Functions let you name a piece of behaviour, test it independently, and reuse it. In C, the crucial thing to understand is the call by value rule — arguments are copied, so a function cannot modify the caller's variables unless you pass addresses. Missing that fact is the source of the most common beginner confusion.

🌍 Where this lives: the call-by-value rule in this topic explains a question people ask in every language. "Why didn't my function change my list in Python?" — because Python passes the reference by value, exactly as C does. Java behaves identically and its documentation says so in these words. Once you understand the swap function below, that confusion never returns in any language. Search "is Java pass by reference" and watch a thousand arguments resolve into this one page.

The three parts

1. DECLARATION (prototype) — tells the compiler the signature, usually before main or in a header: int add(int a, int b); ← note the semicolon 2. DEFINITION — the actual code: int add(int a, int b) { return a + b; } 3. CALL — where you use it: int s = add(3, 4); Without a prototype, calling a function before its definition is an error in modern C (C99 onwards).

Call by value — the rule that surprises everyone

byvalue.c

#include <stdio.h>

void try_to_swap(int a, int b) {   /* gets COPIES */
    int t = a; a = b; b = t;
    printf("  inside: a=%d b=%d\n", a, b);
}

void really_swap(int *a, int *b) {  /* gets ADDRESSES */
    int t = *a; *a = *b; *b = t;
}

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

    try_to_swap(x, y);
    printf("after try:  x=%d y=%d\n", x, y);

    really_swap(&x, &y);
    printf("after real: x=%d y=%d\n", x, y);
    return 0;
}
Output:
  inside: a=20 b=10
after try:  x=10 y=20     <-- unchanged!
after real: x=20 y=10     <-- swapped

Why try_to_swap fails: C copies the ARGUMENT VALUES into new local variables a and b. Swapping those copies has no effect on x and y — they are different memory locations. Why really_swap works: It receives the ADDRESSES of x and y. Dereferencing with * reaches the original memory, so the swap is visible to the caller. C has ONLY call by value. "Call by reference" in C is really "call by value, where the value happens to be an address."

The single exception that confuses people: arrays. Writing void f(int arr[]) looks like passing an array by value, but arrays decay to a pointer to their first element. So modifications inside f DO affect the caller's array — because you were passing an address all along, whether you realised it or not.

Worked example 1 — multiple return values via pointers

divmod.c

#include <stdio.h>

/* A function can return only one value, so extra results
   go out through pointer parameters. */
int divmod(int a, int b, int *rem) {
    if (b == 0) { *rem = 0; return 0; }
    *rem = a % b;
    return a / b;
}

/* min and max of an array, both returned via pointers */
void min_max(const int *arr, int n, int *mn, int *mx) {
    *mn = *mx = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] < *mn) *mn = arr[i];
        if (arr[i] > *mx) *mx = arr[i];
    }
}

int main(void) {
    int r;
    int q = divmod(17, 5, &r);
    printf("17/5 = %d remainder %d\n", q, r);

    int data[] = {45, 12, 78, 3, 56};
    int lo, hi;
    min_max(data, 5, &lo, &hi);
    printf("min=%d max=%d\n", lo, hi);
    return 0;
}
Output:
17/5 = 3 remainder 2
min=3 max=78

Worked example 2 — scope and lifetime

scope.c

#include <stdio.h>

int global = 100;          /* file scope, whole program  */

void demo(void) {
    int local = 1;         /* new each call, dies on exit */
    static int persist = 1;    /* created once, survives      */
    printf("local=%d persist=%d global=%d\n",
           local, persist, global);
    local++; persist++; global++;
}

int main(void) {
    demo();
    demo();
    demo();

    {                      /* a nested block has its own scope */
        int global = 999;  /* SHADOWS the outer one */
        printf("shadowed global = %d\n", global);
    }
    printf("real global = %d\n", global);
    return 0;
}
Output:
local=1 persist=1 global=100
local=1 persist=2 global=101
local=1 persist=3 global=102
shadowed global = 999
real global = 103

Notice three distinct behaviours in one program: local — reset to 1 every call (automatic storage) persist — keeps its value between calls (static) global — shared by everything, accumulates Shadowing: the inner declaration hides the outer one within its block. Legal, but a frequent source of confusion — most style guides forbid it.

Worked example 3 — a complete modular program

stats.c

#include <stdio.h>
#include <math.h>

double mean(const double *a, int n) {
    double s = 0.0;
    for (int i = 0; i < n; i++) s += a[i];
    return s / n;
}

double variance(const double *a, int n) {
    double m = mean(a, n), s = 0.0;   /* reuses mean() */
    for (int i = 0; i < n; i++) s += (a[i]-m) * (a[i]-m);
    return s / n;
}

double std_dev(const double *a, int n) {
    return sqrt(variance(a, n));      /* reuses variance() */
}

int main(void) {
    double marks[] = {72, 85, 63, 91, 78};
    int n = sizeof marks / sizeof marks[0];   /* = 5 */

    printf("n        = %d\n", n);
    printf("mean     = %.2f\n", mean(marks, n));
    printf("variance = %.2f\n", variance(marks, n));
    printf("std dev  = %.2f\n", std_dev(marks, n));
    return 0;
}
Output:
n        = 5
mean     = 77.80
variance = 96.16
std dev  = 9.81

Note the sizeof arr / sizeof arr[0] idiom for array length — it works only where the array is declared, not inside a function that received it as a parameter (where it has decayed to a pointer).

💡 Exam angle: the swap function is asked constantly — show both the failing call-by-value version and the working pointer version, and explain why. State clearly that C has only call by value and that passing an address is how you simulate call by reference. Know that arrays are the exception because they decay to pointers. Scope/lifetime tables with static are also common.

Syllabus points

Declaration, definition, call
Call by value vs reference; scope

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.