Functions in C Part 3: Storage Classes, Function Pointers, and Multi-File Programs

by

In Part 1 we covered the fundamentals, and in Part 2 we covered parameter passing and recursion. In this final part, we look at three more advanced (but very practical) topics: storage classes, function pointers, and how real projects organize functions across multiple files.

Storage Classes

A storage class in C controls two things about a variable: how long it lives in memory (lifetime) and where it’s visible from (scope/linkage). C has four storage class keywords: auto, static, extern, and register.

auto — The Default (and Rarely Written Explicitly)

Every local variable you’ve written so far has actually been auto by default — the keyword is almost never typed explicitly because it’s automatic. It means: created when the function is entered, destroyed when the function exits.

void someFunction() {
    auto int x = 5;   // identical to just writing "int x = 5;"
}

static — Keeping a Local Variable’s Value Between Calls

Normally, a local variable is reset every time a function is called (as we saw with localValue in Part 2). Marking a local variable static changes that: it’s initialized only once, the first time the function runs, and it retains its value across subsequent calls.

#include <stdio.h>

void countCalls() {
    static int count = 0;   // initialized only once, ever
    count++;
    printf("This function has been called %d time(s).\n", count);
}

int main() {
    countCalls();
    countCalls();
    countCalls();
    return 0;
}

Sample Output

This function has been called 1 time(s).
This function has been called 2 time(s).
This function has been called 3 time(s).

Compare this to Part 2’s localValue example, where the local variable was always freshly reset to 100 on every call. Here, count remembers its value between calls because it’s static — it lives in the same memory location for the entire program’s run, not just for one function call, but it’s still only visible inside countCalls() (its scope is unchanged; only its lifetime changes).

static on a Function: Restricting Visibility to One File

static means something different (but related) when applied to a whole function rather than a variable inside it: it restricts that function so it can only be called from within the same source file. This is useful in multi-file projects for “helper” functions that are implementation details of one file and shouldn’t be accessible (or accidentally name-clash) elsewhere.

static int helperOnlyUsedHere(int x) {
    return x * x + 1;
}

extern — Sharing a Global Variable Across Files

extern tells the compiler “this variable exists, but it’s defined in another file — just trust me and link it up later.” It’s how multiple .c files can share one global variable.

// file1.c
int sharedTotal = 0;   // actual definition, allocates memory

// file2.c
extern int sharedTotal;   // declaration only — refers to file1.c's variable

void addToTotal(int value) {
    sharedTotal += value;   // modifies the SAME variable defined in file1.c
}

register — A Hint for Frequently Used Variables

register suggests to the compiler that a variable will be accessed very frequently (e.g. a loop counter) and could benefit from being stored in a CPU register instead of regular RAM for faster access.

void loopExample() {
    register int i;
    for (i = 0; i < 1000000; i++) {
        // tight loop, i is accessed constantly
    }
}

In practice, modern compilers are extremely good at this kind of optimization on their own and largely ignore the register keyword — you'll see it in older textbooks and codebases, but it's rarely necessary to write yourself today. It's included here mainly so you recognize it when reading existing C code.

Function Pointers

Just as a regular pointer stores the address of a variable, a function pointer stores the address of a function — which means you can pass a function as data: store it in a variable, pass it as an argument to another function, or choose which function to call at runtime.

#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; }

int main() {
    // Declare a function pointer: matches "int functionName(int, int)"
    int (*operation)(int, int);

    operation = add;   // point it at the add function (no parentheses/call here)
    printf("add:      %d\n", operation(10, 5));

    operation = subtract;
    printf("subtract: %d\n", operation(10, 5));

    operation = multiply;
    printf("multiply: %d\n", operation(10, 5));

    return 0;
}

Sample Output

add:      15
subtract: 5
multiply: 50

Why This Is Useful: A Menu-Driven Calculator Using an Array of Function Pointers

#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; }

int main() {
    int (*operations[3])(int, int) = {add, subtract, multiply};
    char *names[3] = {"Addition", "Subtraction", "Multiplication"};
    int choice, x = 20, y = 4;

    printf("0: Addition, 1: Subtraction, 2: Multiplication\n");
    printf("Enter choice: ");
    scanf("%d", &choice);

    if (choice >= 0 && choice <= 2) {
        printf("%s of %d and %d = %d\n", names[choice], x, y, operations[choice](x, y));
    } else {
        printf("Invalid choice.\n");
    }

    return 0;
}

Sample Output

0: Addition, 1: Subtraction, 2: Multiplication
Enter choice: 2
Multiplication of 20 and 4 = 80

Instead of a long chain of if-else or switch statements to pick which function to run, the correct function is looked up directly from the array using the user's choice as an index, and called immediately. This pattern (an array or table of function pointers) is how many real-world systems implement things like command dispatchers, event handlers, and plugin systems.

Organizing Functions Across Multiple Files

Real C projects are almost never a single .c file — functions are grouped by purpose into separate files, with a matching header file (.h) that declares (but does not define) what each source file offers to the rest of the program.

A typical 3-file layout for, say, a small math utilities module:

// mathutils.h  (the "menu" — declarations only)
#ifndef MATHUTILS_H
#define MATHUTILS_H

int square(int num);
int cube(int num);

#endif

// mathutils.c  (the actual implementation)
#include "mathutils.h"

int square(int num) {
    return num * num;
}

int cube(int num) {
    return num * num * num;
}

// main.c  (uses the module)
#include <stdio.h>
#include "mathutils.h"

int main() {
    printf("Square of 6: %d\n", square(6));
    printf("Cube of 3: %d\n", cube(3));
    return 0;
}

Compiling this (with gcc, for example) involves both source files:

gcc main.c mathutils.c -o program
./program

Sample Output

Square of 6: 36
Cube of 3: 27

Why the #ifndef / #define / #endif?

This pattern is called an include guard. If two different .c files both #include "mathutils.h", and one of those files also includes another header that itself includes mathutils.h, the header's contents could get pasted in twice during compilation, causing "redefinition" errors. The include guard ensures the header's contents are only processed once per compilation, no matter how many times it's (directly or indirectly) included.

Summary

  • auto is the (rarely written) default for ordinary local variables.
  • static on a local variable makes it retain its value between function calls; on a whole function, it restricts that function to being called only within its own file.
  • extern lets a global variable defined in one file be shared and used in another.
  • register hints at frequent access for a variable; mostly a historical curiosity with modern compilers.
  • Function pointers let you store, pass around, and dynamically choose which function to call — the basis of dispatch tables and callback-style designs.
  • Real programs split functions across .c files with matching .h header files (declarations), using include guards to avoid duplicate-definition errors.

That wraps up this 3-part series on functions in C — from the absolute basics of declaring and calling a function, through parameter passing and recursion, to the storage classes and structural tools used in real multi-file C projects. These ideas form the backbone of almost everything else you'll write in C, so it's worth returning to these posts as a reference whenever a new program calls for them.

Leave a Comment