Functions

Why functions?

Splitting a program into functions gives each job a name (calculate_gst, print_receipt), lets you reuse code, and lets you test pieces separately. Large C programs like the Linux kernel are millions of lines of small functions.

#include <stdio.h>

double with_gst(double amount, double rate);   /* prototype (declaration) */
void print_line(int width);

int main(void) {
    double total = with_gst(1000.0, 18.0);
    print_line(20);
    printf("Total: %.2f\n", total);            /* Total: 1180.00 */
    print_line(20);
    return 0;
}

double with_gst(double amount, double rate) {  /* definition */
    return amount + amount * rate / 100.0;
}

void print_line(int width) {                    /* void: returns nothing */
    for (int i = 0; i < width; i++) putchar('-');
    putchar('\n');
}

Prototypes

The compiler reads a file from top to bottom. A prototype tells it the function's name, return type and parameter types before the call appears, so it can check the call. In old C, calling an undeclared function was allowed and the compiler guessed int; since C99 that is not allowed, and modern GCC (14 and later) reports it as an error ("implicit declaration of function"). Put prototypes at the top of the file or in a header (module 8).

Pass by value

void try_to_double(int n) {
    n = n * 2;                 /* changes only the local copy */
}

int main(void) {
    int x = 10;
    try_to_double(x);
    printf("%d\n", x);         /* still 10 */
    return 0;
}

A function can return only one value. Return the main result, and use pointers (module 5) or a struct (module 7) when you need several.

void and empty parameter lists

Write int main(void) and void print_menu(void) for functions with no parameters. In C before C23, an empty list int f() meant "unknown parameters", which disables checking; in C23 () finally means no parameters too, but (void) is clear in every version.

A function is a contract

Document what each function expects and promises: "is_valid_pin(code) returns 1 if code is a 6-digit number not starting with 0". Small functions with one job and a clear contract are the easiest to test and reuse.