# Introduction to C Functions

> An introduction to functions in C: how they take a name, arguments, a body, and a return value, and why main() is the entry point of every C program.

Author: [Flavio Copes](https://flaviocopes.com/about/) | Published: 2020-02-12 | Topics: [C](https://flaviocopes.com/tags/clang/) | Canonical: https://flaviocopes.com/c-functions/

Functions are the way we can structure our code into subroutines that we can:

1. give a name to
2. call when we need them

Starting from your very first program, an "Hello, World!", you immediately make use of [C](https://flaviocopes.com/c-introduction/) functions:

```c
#include <stdio.h>

int main(void) {
	printf("Hello, World!");
}
```

The `main()` function is a very important function, as it's the entry point for a C program.

Here's another function:

```c
void doSomething(int value) {
	printf("%u", value);
}
```

Functions have 4 important aspects:

1. they have a name, so we can invoke ("call") them later
2. they specify a return value
3. they can have arguments
4. they have a body, wrapped in curly braces

The function body is the set of instructions that are executed any time we invoke a function.

If the function has no return value, you can use the keyword `void` before the function name. Otherwise you specify the function return value type (`int` for an integer, `float` for a floating point value, `const char *` for a string, etc).

You cannot return more than one value from a function.

A function can have arguments. They are optional. If it does not have them, inside the parentheses we insert `void`, like this:

```c
void doSomething(void) {
   /* ... */
}
```

In this case, when we invoke the function we'll call it with nothing in the parentheses:

```c
doSomething();
```

If we have one parameter, we specify the type and the name of the parameter, like this:

```c
void doSomething(int value) {
   /* ... */
}
```

When we invoke the function, we'll pass that parameter in the parentheses, like this:

```c
doSomething(3);
```

We can have multiple parameters, and if so we separate them using a comma, both in the declaration and in the invocation:

```c
void doSomething(int value1, int value2) {
   /* ... */
}

doSomething(3, 4);
```

Parameters are passed by **copy**. This means that if you modify `value1`, its value is modified locally, and the value outside of the function, where it was passed in the invocation, does not change.

If you pass a [pointer](https://flaviocopes.com/c-pointers/) as a parameter, you can modify that variable value because you can now access it directly using its memory address.

You can't define a default value for a parameter. C++ can do that (and so Arduino Language programs can), but C can't.

Make sure you define the function before calling it, or the compiler will raise a warning and an error:

```
➜  ~ gcc hello.c -o hello; ./hello
hello.c:13:3: warning: implicit declaration of
      function 'doSomething' is invalid in C99
      [-Wimplicit-function-declaration]
  doSomething(3, 4);
  ^
hello.c:17:6: error: conflicting types for
      'doSomething'
void doSomething(int value1, char value2) {
     ^
hello.c:13:3: note: previous implicit declaration
      is here
  doSomething(3, 4);
  ^
1 warning and 1 error generated.
```

The warning you get regards the ordering, which I already mentioned.

The error is about another thing, related. Since C does not "see" the function declaration before the invocation, it must make assumptions. And it assumes the function to return `int`. The function however returns `void`, hence the error.

If you change the function definition to:

```c
int doSomething(int value1, int value2) {
  printf("%d %d\n", value1, value2);
  return 1;
}
```

you'd just get the warning, and not the error:

```
➜  ~ gcc hello.c -o hello; ./hello
hello.c:14:3: warning: implicit declaration of
      function 'doSomething' is invalid in C99
      [-Wimplicit-function-declaration]
  doSomething(3, 4);
  ^
1 warning generated.
```

In any case, make sure you declare the function before using it. Either move the function up, or add the function prototype in a header file.

Inside a function, you can declare variables.

```c
void doSomething(int value) {
  int doubleValue = value * 2;
}
```

A variable is created at the point of invocation of the function, and is destroyed when the function ends, and it's not visible from the outside.

Inside a function, you can call the function itself. This is called **recursion** and it's something that offers peculiar opportunities.