🌱 C Basics

Functions: name it once, use it forever

⏱ 14 min · free interactive lesson · quizzes, visualizations & a real compiler

You've been using functions since your first printf — now you get to make them. A function packages a piece of logic behind a name: define it once, call it from anywhere, trust it to do its job. It is the single most important tool for taming complexity in C.

Anatomy of a function

#include <stdio.h>

int square(int n) {          /* definition: the real thing */
    return n * n;
}

void greet(void) {           /* returns nothing, takes nothing */
    printf("Hello from a function!\n");
}

int main(void) {
    greet();
    int a = square(6);       /* call: argument 6 -> parameter n */
    printf("square(6)  = %d\n", a);
    printf("square(a)  = %d\n", square(a));  /* results compose */
    return 0;
}

$ gcc square.c -o square && ./square
Hello from a function!
square(6)  = 36
square(a)  = 1296

• Return type (int) — the type of value handed back. Use the keyword void for "returns nothing".
• Name (square) — pick verbs for actions, nouns for computations.
• Parameters (int n) — fresh local variables, filled in with the caller's arguments at each call. A function taking nothing declares (void).
• return — stops the function immediately and delivers the value. A void function may use bare return; or just fall off the end.

Declaration vs definition: promises vs delivery

C compilers read top to bottom, and a function must be known before it's called. Two ways to arrange that:

1. Define the function above its callers (fine for small files), or
2. Put a prototype — the header line ending in a semicolon — near the top, and define the body anywhere:

#include <stdio.h>

double celsius_to_f(double c);   /* PROTOTYPE: a promise */

int main(void) {
    printf("100 C = %.1f F\n", celsius_to_f(100.0));
    printf("37 C  = %.1f F\n", celsius_to_f(37.0));
    return 0;
}

/* DEFINITION: the promise, delivered (below its caller!) */
double celsius_to_f(double c) {
    return c * 9.0 / 5.0 + 32.0;
}

A prototype is a declaration: "a function with this name, these parameter types, this return type exists — trust me." The definition with the body is the delivery on that promise. Headers like stdio.h are, at heart, just bundles of prototypes — that's the missing piece of the #include story from lesson one. Promise a function and never define it, and you'll meet our old friend from Part 0: the linker's undefined reference.

The big rule: arguments are passed BY VALUE

When you call doubler(x), the parameter does not become x — it receives a copy of x's value, in a brand-new variable inside the function's own stack frame (remember Part 0's stack?). Modify the copy all you like; the original never notices:

#include <stdio.h>

void doubler(int n) {
    n = n * 2;               /* modifies the COPY  */
    printf("  inside : n = %d\n", n);
}

int main(void) {
    int x = 10;
    printf("before  : x = %d\n", x);
    doubler(x);
    printf("after   : x = %d  <- unchanged!\n", x);
    return 0;
}

$ gcc byvalue.c -o byvalue && ./byvalue
before  : x = 10
  inside : n = 20
after   : x = 10  <- unchanged!

Here's the memory picture at the moment doubler sets n = 20 — two separate cells, two separate lives:

▶ This spot has an interactive memgrid widget — open the interactive lesson to play with it.

▶ This spot has an interactive editor widget — open the interactive lesson to play with it.

Functions create little private worlds for their variables — the precise rules of who can see what, and for how long, are our final Part 1 topic: scope and lifetime.