Functions in C

Functions are the unit of organization in C. As a procedural, imperative language, C builds programs by composing small, named blocks of code that each do one job. You have already met one function - main, the entry point of every C program. In this tutorial you will learn how to write your own.

C functions are deliberately simple: a function has a return type, a name, a parameter list, and a body. There are no methods, no classes, and no closures - just plain functions that take values and return values. Because C is a static, weakly typed language, the compiler checks the types of arguments against the function’s declaration, but it will also quietly convert between numeric types when it can.

Two ideas are central to using functions well in C. First, arguments are passed by value - a function receives a copy of each argument, so changing a parameter inside a function does not affect the caller. To let a function modify the caller’s data, you pass a pointer. Second, functions should usually be declared before they are used with a prototype, so the compiler knows their signature. We will cover both, along with recursion and function pointers - C’s way of treating functions as data.

Defining and Calling Functions

A function declaration (a prototype) tells the compiler the function’s signature; the definition supplies the body. Prototypes are commonly placed above main, with the definitions below it.

Create a file named functions_basic.c:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <stdio.h>

/* Function prototypes (declarations) */
int add(int a, int b);
double average(int a, int b);
void greet(const char *name);

int main(void) {
    int sum = add(7, 5);
    printf("7 + 5 = %d\n", sum);
    printf("Average of 7 and 5 = %.1f\n", average(7, 5));
    greet("Archaeologist");
    return 0;
}

/* Function definitions */
int add(int a, int b) {
    return a + b;
}

double average(int a, int b) {
    return (a + b) / 2.0;   /* 2.0 forces floating-point division */
}

void greet(const char *name) {
    printf("Hello, %s!\n", name);   /* void: returns nothing */
}

Each function has a return type (int, double, or void for “no return value”), a name, and a typed parameter list. The return statement hands a value back to the caller. A void function performs an action - here, printing - and needs no return value.

Pass-by-Value and Pass-by-Pointer

C always passes arguments by value: the function works on a copy. If you want a function to change a variable in the caller, you pass its address and the function works through a pointer.

Create a file named scope.c:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <stdio.h>

void try_double(int n) {
    n = n * 2;   /* modifies only the local copy */
    printf("Inside try_double: n = %d\n", n);
}

void really_double(int *n) {
    *n = *n * 2; /* dereference: modifies the caller's variable */
}

int main(void) {
    int value = 10;

    try_double(value);
    printf("After try_double:   value = %d\n", value);

    really_double(&value);   /* &value is the address of value */
    printf("After really_double: value = %d\n", value);

    return 0;
}

try_double receives a copy, so the caller’s value is untouched. really_double receives a pointer (int *), and *n reaches back through that address to modify the original. The & operator takes the address of a variable; * dereferences a pointer. This distinction is fundamental to how C handles scope and mutation.

Recursion

A function may call itself. Recursion expresses problems defined in terms of smaller versions of themselves, such as the factorial of a number.

Create a file named recursion.c:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <stdio.h>

/* Recursive factorial: n! = n * (n-1)!, with 0! = 1! = 1 */
unsigned long factorial(int n) {
    if (n <= 1) {
        return 1;                  /* base case stops the recursion */
    }
    return n * factorial(n - 1);   /* recursive case */
}

int main(void) {
    for (int i = 1; i <= 6; i++) {
        printf("%d! = %lu\n", i, factorial(i));
    }
    return 0;
}

Every recursive function needs a base case that returns without recursing - here, n <= 1. Without it, the function would call itself forever and overflow the call stack. The %lu format specifier prints an unsigned long, which holds larger factorials than a plain int.

Function Pointers

In C, a function has an address, so you can store it in a function pointer and pass it to another function. This lets you write higher-order functions - functions that take other functions as parameters.

Create a file named function_pointers.c:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <stdio.h>

int add(int a, int b)      { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }

/* op is a pointer to a function taking two ints and returning an int */
int apply(int (*op)(int, int), int x, int y) {
    return op(x, y);
}

int main(void) {
    printf("apply(add, 6, 4)      = %d\n", apply(add, 6, 4));
    printf("apply(subtract, 6, 4) = %d\n", apply(subtract, 6, 4));
    printf("apply(multiply, 6, 4) = %d\n", apply(multiply, 6, 4));
    return 0;
}

The parameter int (*op)(int, int) is a pointer to a function. Passing add, subtract, or multiply lets apply call whichever operation you choose at runtime. Function pointers power callbacks, dispatch tables, and plug-in style designs throughout C codebases like the Linux kernel.

Running with Docker

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Pull the official GCC image
docker pull gcc:14

# Compile and run each example
docker run --rm -v $(pwd):/app -w /app gcc:14 \
    sh -c "gcc -o functions_basic functions_basic.c && ./functions_basic"

docker run --rm -v $(pwd):/app -w /app gcc:14 \
    sh -c "gcc -o scope scope.c && ./scope"

docker run --rm -v $(pwd):/app -w /app gcc:14 \
    sh -c "gcc -o recursion recursion.c && ./recursion"

docker run --rm -v $(pwd):/app -w /app gcc:14 \
    sh -c "gcc -o function_pointers function_pointers.c && ./function_pointers"

Expected Output

functions_basic.c:

7 + 5 = 12
Average of 7 and 5 = 6.0
Hello, Archaeologist!

scope.c:

Inside try_double: n = 20
After try_double:   value = 10
After really_double: value = 20

recursion.c:

1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720

function_pointers.c:

apply(add, 6, 4)      = 10
apply(subtract, 6, 4) = 2
apply(multiply, 6, 4) = 24

Key Concepts

• Prototypes come first - declare a function’s signature before it is used so the compiler can check calls; place definitions below main or in separate files.
• Return type and parameters are typed - every function states what it returns (int, double, void) and the type of each parameter.
• Arguments are passed by value - a function gets a copy, so it cannot change the caller’s variables directly.
• Pointers enable mutation - pass an address with & and dereference with * to let a function modify the caller’s data.
• void means no return value - used for functions that act through side effects, like printing.
• Recursion needs a base case - a self-calling function must have a condition that stops it, or it overflows the stack.
• Functions are addressable - function pointers let you store and pass functions, enabling callbacks and higher-order functions.
• Match format specifiers to types - use %d for int, %lu for unsigned long, %.1f for a double, and %s for a string.