C Function Declaration: Informing the Compiler

A **Function Declaration** (also known as a **Function Prototype**) tells the compiler about a function's name, return type, and parameters before the function is actually defined. This is essential for maintaining organized code, especially when functions call each other or are defined after the main() function.

1. Declaration vs. Definition

To use functions professionally, you must distinguish between these two phases:

Declaration: Specifies the function's "signature" (name, return type, parameters). It ends with a semicolon.
Definition: Contains the actual body of the function (the code to be executed).

2. Why is Declaration Necessary?

In C, if you define a function *after* the main() function without a declaration at the top, the compiler will assume the function returns an int and might not check the parameters correctly. This leads to "implicit declaration" errors.

#include <stdio.h>

// 1. Function Declaration (Prototype)
void myFunction(int age);

int main() {
    myFunction(25); // 2. Function Call
    return 0;
}

// 3. Function Definition
void myFunction(int age) {
    printf("Age is %d", age);
}

3. The Components of a Declaration

A declaration consists of three main parts, which must perfectly match the definition that follows later:

Component	Purpose
Return Type	What kind of value the function sends back (int, void, etc.).
Function Name	The identifier used to invoke the code.
Parameter List	The types of data the function expects (e.g., `int, float`).

4. Best Practices: Header Files

In large professional projects, declarations are usually placed in Header Files (.h files), while definitions are kept in Source Files (.c files). This is how libraries like stdio.h work. You see the declaration (prototype) when you include the header, but the actual code (definition) is hidden in the pre-compiled library.

5. Common Mistakes

Missing Semicolon: Declarations *must* end with a semicolon (;), while definitions *must not* have a semicolon before the curly braces.
Signature Mismatch: If the declaration says int add(int a, int b); but the definition says float add(int a, int b) {...}, the compiler will throw a "conflicting types" error.
Parameter Names: Interestingly, you don't actually need variable names in a declaration. void sum(int, int); is perfectly valid, though void sum(int a, int b); is better for readability.

Pro Tip: Always place your function declarations at the top of your file, just below the #include statements. This makes your code modular and ensures that functions can call each other regardless of the order in which they are defined.