> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C Function Definition
A function definition in C provides the actual implementation of a function, binding an identifier and a signature to a block of executable statements. Unlike a function declaration (or prototype) which only informs the compiler about a function's interface, the definition allocates memory for the function's instructions and specifies the exact operations to be performed upon invocation.
```c theme={"dark"}
[storage_class_specifier] [function_specifier] return_type function_name(parameter_list) {
// function body (compound statement)
}
```
## Structural Components
A standard C function definition consists of two primary parts: the function header and the function body.
### 1. Function Header
The header establishes the function's interface and consists of up to five elements:
* **`storage_class_specifier` (Optional)**: Determines the function's linkage. The `static` keyword restricts linkage to the current translation unit (internal linkage), while `extern` explicitly declares external linkage (which is the default if omitted).
* **`function_specifier` (Optional)**: Provides specific directives to the compiler. Examples include `inline` (suggesting inline substitution) and `_Noreturn` (indicating the function never returns control to its caller).
* **`return_type`**: Specifies the C data type of the value the function yields to the calling environment. If the function does not return a value, the `void` keyword must be used.
* **`function_name`**: A unique identifier used to invoke the function. It must adhere to standard C identifier naming rules.
* **`parameter_list`**: A comma-separated sequence of parameter declarations enclosed in parentheses. Each parameter requires both a type specifier and an identifier (e.g., `int x, float y`). If the function accepts no arguments, the keyword `void` should be explicitly placed within the parentheses.
### 2. Function Body
The body is a compound statement enclosed in curly braces `{}`. It dictates the function's behavior and contains:
* **Local Declarations**: Variables declared within this block possess block scope and automatic storage duration by default.
* **Executable Statements**: The sequence of operations the function performs.
* **`return` Statement**: Terminates function execution and passes control back to the caller. If the `return_type` is not `void`, the `return` statement must evaluate to a value compatible with the `return_type`. Reaching the closing brace `}` of a non-`void` function without executing a `return` statement is permitted by the compiler, but results in undefined behavior if the caller attempts to use the return value (with the exception of `main` in C99 and later, which implicitly returns `0`).
## Concrete Example
```c theme={"dark"}
static inline int calculate_sum(int operand_a, int operand_b) {
int result = operand_a + operand_b;
return result;
}
```
## Technical Characteristics
* **Linkage and Definition Rules**: By default, function definitions possess external linkage, meaning they are visible and callable across multiple translation units. A function with external linkage must be defined exactly once across the entire program. However, functions with internal linkage (`static`) and `inline` functions can be legally defined in multiple translation units within the same C program without violating definition rules.
* **Implicit Declaration**: If a function definition appears in a translation unit before it is called, the definition inherently acts as the function's declaration for subsequent code in that file.
* **Parameter Shadowing**: Identifiers used in the `parameter_list` are local to the function body and will shadow any global variables sharing the same identifier.
Tired of Poor C Skills? Fix That With Deep Grasping!
Learn More
