Functions in C: Declaring, Calling, and Returning Values

Why Functions

Everything so far has lived inside main. That works until a program does more than one thing, and then three problems arrive at once: the same block of code gets copied into three places, main grows past what anyone can hold in their head, and there is no way to name what a chunk of code is for.

A function fixes all three. It gives a block of code a name, its own local variables, a list of inputs, and a single value to hand back.

#include <stdio.h>

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

int main(void) {
    printf("%d\n", square(4));
    printf("%d\n", square(9));
    printf("%d\n", square(square(2)));
    return 0;
}

square is written once and called three times, including once on its own result. You have already been calling functions - printf is one, and so is main.

Anatomy of a Function

returnType name(parameterList) {
    // body
    return value;
}

Four parts:

• Return type - the type of the value the function hands back. int, double, char, a pointer type, or void for "nothing".
• Name - follows the same rules as a variable name, and should say what the function does or produces.
• Parameter list - the inputs, each with its own type, separated by commas. (void) means it takes none.
• Body - the statements, in braces, ending with a return unless the return type is void.

#include <stdio.h>

/* takes two ints, produces one int */
int add(int a, int b) {
    return a + b;
}

/* takes nothing, produces a double */
double pi(void) {
    return 3.14159265358979;
}

/* takes an int, produces nothing */
void printBanner(int width) {
    for (int i = 0; i < width; i++) {
        printf("=");
    }
    printf("\n");
}

int main(void) {
    printBanner(20);
    printf("2 + 3 = %d\n", add(2, 3));
    printf("pi     = %f\n", pi());
    printBanner(20);
    return 0;
}

Note pi() still needs the empty parentheses at the call site - that is what makes it a call rather than a mention of the name. And printBanner(20); is a statement on its own, because it produces no value to use.

Write (void), not (), for a function with no parameters. In C those two mean different things, and () is the loose one - more on that shortly.

Calling and Returning

A call transfers control into the function, runs its body, and comes back with a value that replaces the call in the surrounding expression.

#include <stdio.h>

int larger(int a, int b) {
    if (a > b) {
        return a;      /* leaves the function immediately */
    }
    return b;
}

int main(void) {
    int x = larger(17, 42);
    printf("larger(17, 42) = %d\n", x);
    printf("nested: %d\n", larger(larger(3, 9), 5));
    return 0;
}

return does two things at once: it supplies the value and it ends the function on the spot. Anything after a return on the same path never runs, which is what makes the early-return style in larger work - no else is needed, because reaching the last line already means a > b was false.

A function can have several return statements. It can only ever execute one of them per call.

void Functions

A function that exists for its effect rather than its value has the return type void: printing, updating something through a pointer, drawing.

#include <stdio.h>

void printTable(int n, int upTo) {
    for (int i = 1; i <= upTo; i++) {
        printf("%d x %d = %d\n", n, i, n * i);
    }
}

void warn(const char *message, int enabled) {
    if (!enabled) {
        return;            /* bare return: just leave early */
    }
    printf("WARNING: %s\n", message);
}

int main(void) {
    printTable(7, 5);
    warn("low disk space", 1);
    warn("this one is suppressed", 0);
    return 0;
}

Inside a void function, return; with no value exits early. return someValue; is a compile error there, and so is using the call in an expression - int x = printTable(7, 5); will not compile, which is the type system doing its job.

Decomposition: The Real Point

Functions are not mainly about avoiding repetition. They are about turning one long procedure into a few named steps, so that main reads like a description of the program rather than its implementation.

#include <stdio.h>

double average(const int values[], int count) {
    if (count == 0) {
        return 0.0;
    }
    int total = 0;
    for (int i = 0; i < count; i++) {
        total += values[i];
    }
    return (double) total / count;
}

int highest(const int values[], int count) {
    int best = values[0];
    for (int i = 1; i < count; i++) {
        if (values[i] > best) {
            best = values[i];
        }
    }
    return best;
}

int countAbove(const int values[], int count, int threshold) {
    int n = 0;
    for (int i = 0; i < count; i++) {
        if (values[i] > threshold) {
            n++;
        }
    }
    return n;
}

int main(void) {
    int scores[] = {88, 92, 75, 60, 100, 47, 83};
    int n = sizeof(scores) / sizeof(scores[0]);

    double avg = average(scores, n);

    printf("Count:            %d\n", n);
    printf("Average:          %.2f\n", avg);
    printf("Highest:          %d\n", highest(scores, n));
    printf("Above average:    %d\n", countAbove(scores, n, (int) avg));
    return 0;
}

main is now four lines of output and one calculation. Each helper does one thing, has a name that says what that thing is, and can be tested on its own. Notice that the array's length travels as a second parameter: once an array is passed to a function the sizeof trick no longer works there, because the array decays to a pointer.

Three rules of thumb for splitting work into functions:

• One job per function. If the name needs an "and" in it, it is probably two functions.
• Take what you need, return what you produce. A function that reads global state is harder to reason about and impossible to test in isolation.
• Short enough to see at once. There is no magic line count, but a function that does not fit on a screen is usually hiding a smaller function inside it.

Functions Calling Functions

A function can call any function that has already been declared, including ones you wrote:

#include <stdio.h>

int isEven(int n) {
    return n % 2 == 0;
}

int sumEvens(const int a[], int n) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        if (isEven(a[i])) {
            total += a[i];
        }
    }
    return total;
}

void report(const int a[], int n) {
    printf("Sum of even values: %d\n", sumEvens(a, n));
}

int main(void) {
    int data[] = {3, 8, 12, 5, 7, 20};
    report(data, sizeof(data) / sizeof(data[0]));
    return 0;
}

main calls report, which calls sumEvens, which calls isEven inside a loop. Each call gets its own fresh set of local variables, stacked on top of the caller's, and they are discarded when it returns.

The definitions above are in dependency order - isEven before sumEvens before report - because C requires a function to be declared before it is called. Call one that appears further down the file and the compiler complains about an implicit declaration. The general fix is a prototype near the top of the file, which lets you order definitions however you like. A function calling itself is legal and useful too; that is recursion.

main Is a Function

main is an ordinary function that the runtime calls for you. Its int return type is the program's exit status: 0 means success, nonzero means failure, and shell scripts and build tools read it.

int main(void) {
    /* ... */
    return 0;
}

Since C99, falling off the end of main without a return implicitly returns 0 - a special rule that applies to main only. Every other non-void function that ends without returning a value produces undefined behavior when the caller uses the result.

The other standard form is int main(int argc, char *argv[]), which receives command-line arguments. Both are correct; void main() is not, whatever old tutorials say.

Common Mistakes

• Forgetting return in a non-void function. The caller then reads a garbage value. gcc -Wall warns.
• Declaring a variable with the same name as a parameter inside the body. It shadows the parameter, and the assignment you meant to make to the input goes nowhere.
• Expecting a function to change its arguments. C passes everything by value, so a function receives copies. void reset(int x) { x = 0; } changes nothing at the call site - the subject of the next page.
• Omitting the parentheses in a call. printBanner; is a legal expression that evaluates the function's address and discards it. It compiles, does nothing, and -Wall flags it.
• Writing () instead of (void). Legal, but it turns off argument checking in older C dialects.