C Function Prototypes (Declarations)

Up to now, every function you wrote had to sit above main, or the compiler complained. That works for small files, but it pushes main, the most important part, to the very bottom. C function prototypes solve this. In this lesson, you'll learn what a prototype is, why the compiler needs one, the difference between a declaration and a definition, and how prototypes keep your programs organized.

What is a function prototype in C?

A function prototype is a declaration of a function: its return type, name and parameter types, followed by a semicolon, with no body. It tells the compiler, "a function with this shape exists; its code comes later".

double to_fahrenheit(double celsius);   /* prototype: ends with ; */

Compare it with the full function, which has a body in curly braces:

double to_fahrenheit(double celsius) {  /* definition: has a body */
    return celsius * 9.0 / 5.0 + 32.0;
}

Why does the compiler need prototypes?

The compiler reads your source file once, from top to bottom. When it reaches a function call, it needs to know right away:

• Does a function with this name exist?
• How many arguments does it take, and of what types? (So it can check your call and convert values if needed.)
• What type does it return? (So it knows how to use the result.)

If the function's definition comes after the call, the compiler hasn't seen any of this yet. A prototype at the top answers all three questions in advance.

What happens without a prototype?

Here's the problem in code. main calls to_fahrenheit, but the function is defined below it and there's no prototype:

#include <stdio.h>

int main(void) {
    printf("%.1f\n", to_fahrenheit(21.5));   /* not known yet! */
    return 0;
}

double to_fahrenheit(double celsius) {
    return celsius * 9.0 / 5.0 + 32.0;
}

GCC 14 and later refuse to compile this. The error points at the call and says implicit declaration of function 'to_fahrenheit'. An "implicit declaration" means the compiler would have to guess what the function looks like, and since the C99 standard, guessing is not allowed.

Older GCC versions only warn and then guess that the function returns an int. When they later reach the real definition, which returns a double, they also report conflicting types for 'to_fahrenheit'. Either way, the fix is the same: add a prototype.

How to write a function prototype

Copy the first line of the definition (the header) and end it with a semicolon. Put it near the top of the file, after the #include lines and before main:

#include <stdio.h>

double to_fahrenheit(double celsius);
void print_reading(int room, double celsius);

int main(void) {
    print_reading(1, 21.5);
    print_reading(2, 18.0);
    return 0;
}

void print_reading(int room, double celsius) {
    printf("Room %d: %.1f C = %.1f F\n", room, celsius, to_fahrenheit(celsius));
}

double to_fahrenheit(double celsius) {
    return celsius * 9.0 / 5.0 + 32.0;
}

Room 1: 21.5 C = 70.7 F
Room 2: 18.0 C = 64.4 F

Thanks to the prototypes, the order of the definitions no longer matters. main comes first, print_reading calls to_fahrenheit even though it's defined after it, and everything compiles cleanly.

Declaration vs definition: what's the difference?

These two words are used constantly in C, so it's worth getting them straight:

A definition also counts as a declaration. That's why defining a function above main worked in the earlier lessons: the definition introduced the function before its first use.

Are parameter names required in a prototype?

No. The compiler only needs the types, so these two prototypes mean exactly the same thing:

double area(double width, double height);
double area(double, double);

The names in a prototype don't even have to match the names in the definition. Still, most programmers keep the names, because area(double width, double height) tells a reader which number is which, while area(double, double) does not.

Real-world example: main as a table of contents

With prototypes, main reads like a summary of the whole program. This receipt printer lists its three helpers at the top, so a reader sees the plan before the details:

#include <stdio.h>

void print_header(void);
void print_item(int quantity, double unit_price);
double line_total(int quantity, double unit_price);

int main(void) {
    print_header();
    print_item(2, 3.50);
    print_item(1, 12.00);
    return 0;
}

void print_header(void) {
    printf("Qty  Price   Total\n");
}

void print_item(int quantity, double unit_price) {
    printf("%3d  %5.2f  %6.2f\n", quantity, unit_price, line_total(quantity, unit_price));
}

double line_total(int quantity, double unit_price) {
    return quantity * unit_price;
}

Qty  Price   Total
  2   3.50    7.00
  1  12.00   12.00

The widths in %3d, %5.2f and %6.2f right-align the numbers into neat columns (see format specifiers).

Where else do prototypes come from?

You've been using prototypes since your first program without noticing. The line #include <stdio.h> pastes in a file full of declarations, including the prototype of printf. That's how the compiler knows how to check your printf calls even though you never wrote that function. In bigger projects, you'll put your own prototypes in header files and share them across multiple source files.

Common mistakes with function prototypes

1. A prototype that doesn't match the definition

int area(int width, int height);          /* prototype says int */

double area(double width, double height) { /* definition says double */
    return width * height;
}

GCC stops with conflicting types for 'area'. The return type and every parameter type must match exactly.

2. Forgetting the semicolon

Without the ;, the compiler thinks a function body should follow and reports a confusing syntax error on the next line, often pointing at int main. If an error appears right after your prototypes, check their semicolons first.

3. Using empty parentheses

void print_header();      /* old style: parameters unknown */
void print_header(void);  /* clear: takes no parameters */

Before C23, empty parentheses in a declaration mean "parameters not specified", which switches off argument checking: a wrong call like print_header(42) compiles silently. Always write (void).

4. Declaring but never defining

If you write a prototype and call the function but forget to write its definition, compiling succeeds, but the final linking step fails with an undefined reference to the function. A prototype is only a promise; the definition must exist somewhere.

Practice exercise

#include <stdio.h>

int square(int n);
void print_squares(int limit);

int main(void) {
    print_squares(5);
    return 0;
}

void print_squares(int limit) {
    for (int i = 1; i <= limit; i++) {
        printf("%d ", square(i));
    }
    printf("\n");
}

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

1 4 9 16 25 

What's next?

You now know how to declare, define, call and organize functions. Next, find out where variables live and how long they last with C scope and storage classes.