---
tags:
  - C
---

## What type is a function?

A function does not have to a dedicated primitive type. It is a **derived**
type, meaning that its type-signature comes from the primitive types that it
uses.

On this basis, a function type is derived from its return type and the number
and types of its parameters.

E.g. for the function:

```c
int mimic_number(int num) {
    return num;
}
```

It's type is a product of:

- its return type (`int`)
- the number of parameters (`1`)
- the type of its parameter (`int`)

## Function declarators and function definitions

In C, it is possible to declare a function without specifying the body, e.g:

```c
int f(void);
void g(int i, int j);
```

Are all examples of function declarators.

Later then you can go back and provide the definition. Note that this is just
the same as a normal full function declaration, it's just you've previously
declared its existence:

```c

int f(void);

// Some other code

int f(void) {
    printf("Here's the definition.")
}
```

### What's the point of this?

The only real utility in distinguishing the declaration from the definition is
when creating reusable libraries.

These follow this sequence:

- define a `.h` header file with function declaration
- define a `.c` file with the function definition
- import the function into `main.c` and call function

Applied example:

```c
// math_utils.h

int add (int a, int b);
```

```c
// math_utils.c
int add (int a, int b) {
    return a + b;
}
```

And then in `main.c`:

```c
#include "math_utils.h"

int main(void):
    int sum = add(5, 3)
```

> The compiler compiles each .c file separately. The header file tells main.c
> that add and multiply exist somewhere, even though they're defined in a
> different file. The linker connects everything together at the end.

In C, the distinction between arguments and parameters is more acute than other
languages: