Function Prototype in C

In C, a function prototype is a statement that tells the compiler about the function’s name, its return type, numbers, and data types of its parameters. Using this information, the compiler cross-checks function parameters and their data type with function definition and function call.

For example, let's create a function prototype for a function that adds two numbers which it takes as arguments and returns their sum:

// Not a prototype as it does not contain the number
// and type of parameters. It is only declaration
int sum();

// Valid prototype as it contains function name,
// return type, number and type of parameters
int sum(int, int);

// Also a valid prototype
int sum(int a, int b);

// Function definition inherently contains function
// prototype
int sum(int a, int b) {
  	return a + b;
}

General Syntax

return_type name(type1, type2 ....);

where,

• return_type : Type of value the function returns.
• name: Name of the function
• type1, type2 ....: Type of the parameters. Specifying their names is optional.

Function prototype can be used in place of function declaration in cases where the function reference or call is present before the function definition but optional if the function definition is present before the function call in the program.

What Happens If the Function Prototype Is Missing?

When the function prototype is missing in C, the compiler generally gives two warnings:

1. Implicit Declaration Warning.
2. Incorrect return type warning (in case where the function should return non-integer value)

The first warning is understandable as the compiler cannot find the function with the given name. The other warning is due to the fact that the compiler assumes the return type to be int by default in case of missing return type(or whole prototype).

The below program demonstrate this:

#include <errno.h>
#include <stdio.h>

int main(int argc, char* argv[]) {
	FILE* fp;

	fp = fopen(argv[1], "r");
	if (fp == NULL) {
      
      	// Calling strerror() which is defined inside
      	// string.h header file
		fprintf(stderr, "%s\n", strerror(errno));
		return errno;
	}

	printf("file exist\n");

	fclose(fp);

	return 0;
}

Output

solution.c: In function ‘main’:
solution.c:14:41: warning: implicit declaration of function ‘strerror’; did you mean ‘perror’? [-Wimplicit-function-declaration]
   14 |                 fprintf(stderr, "%s\n", strerror(errno));
      |                                         ^~~~~~~~
      |                                         perror
solution.c:14:35: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int’ [-Wformat=]
   14 |                 fprintf(stderr, "%s\n", strerror(errno));
      |                                  ~^     ~~~~~~~~~~~~~~~
      |                                   |     |
      |                                   |     int
      |                                   char *
      |                                  %d
Segmentation fault (core dumped)

Explanation

The above program checks the existence of a file, provided from the command line, if a given file exists, then the program prints “file exists”, otherwise it prints an appropriate error message.

Why did this program crash, instead it should show an appropriate error message. This program will work fine on x86 architecture but will crash on x86_64 architecture. Let us see what was wrong with the code. Carefully go through the program, deliberately I haven’t included the prototype of the “strerror()” function. This function returns a “pointer to the character”, which will print an error message which depends on the errno passed to this function.

Note that x86 architecture is an ILP-32 model, which means integers, pointers, and long are 32-bit wide, that’s why the program will work correctly on this architecture. But x86_64 is the LP-64 model, which means long and pointers are 64-bit wide. In C language, when we don’t provide a prototype of a function, the compiler assumes that the function returns an integer. In our example, we haven’t included the “string.h” header file (strerror’s prototype is declared in this file), that’s why the compiler assumed that the function returns an integer. But its return type is a pointer to a character.

In x86_64, pointers are 64-bit wide and integers are 32-bit wide, that’s why while returning from a function, the returned address gets truncated (i.e. 32-bit wide address, which is the size of integer on x86_64) which is invalid and when we try to dereference this address, the result is a segmentation fault.

Now include the “string.h” header file and check the output, the program will work correctly and gives the following output.

Benifits of Function Prototypes

Following are the major benefits of including function prototypes in your program:

• Function Declaration Before Definition: It allows a function to be called before its definition. In large programs, it is common to place function prototypes at the beginning of the code or in header files, enabling function calls to occur before the function’s actual implementation.
• Type Checking: A function prototype allows the compiler to check that the correct number and type of arguments are passed to the function. If the function is called with the wrong type or number of parameters, the compiler can catch the error.
• Code Clarity: By declaring prototypes, you inform the programmer about the function's purpose and expected parameters, which helps in understanding the code structure.

Function Declaration vs Prototype

The terms function declaration and function prototypes are often used interchangeably but they are different in the purpose and their meaning. Following are the major differences between the function declaration and function prototype in C:

kartik

Follow

Improve

Article Tags :

• C Language
• C-Functions