programmationc/fonctions.md

# Les fonctions

En langage C, une **fonction** est un bloc de code nommé qui réalise une tâche précise. Les fonctions permettent de :

* Découper un programme en parties plus simples
* Réutiliser du code sans duplication
* Rendre le code plus lisible et plus facile à maintenir
* Faciliter les tests et le débogage

Tout programme C contient au minimum une fonction : `main`.

---

## Structure générale d’une fonction

Une fonction en C se compose de :

1. Un **type de retour**
2. Un **nom**
3. Une liste de **paramètres** (éventuellement vide)
4. Un **corps**, délimité par des accolades `{}`

```c
type_retour nom_fonction(type1 param1, type2 param2)
{
    instructions;
    return valeur;
}
```

Exemple simple :

```c
int addition(int a, int b)
{
    return a + b;
}
```

## La fonction `main`

Le point d’entrée d’un programme C est la fonction `main`.

Exemple minimal :

```c
#include <stdio.h>

int main(void)
{
    printf("Bonjour le monde !\n");
    return 0;
}
```

* `int` : type de retour (code de sortie du programme)
* `return 0` : indique que le programme s’est terminé correctement

---

## Déclaration et définition d’une fonction

### Définition

La **définition** contient le code réel de la fonction.

```c
int carre(int x)
{
    return x * x;
}
```

### Déclaration (prototype)

La **déclaration** informe le compilateur de l’existence de la fonction.

```c
int carre(int x);
```

Elle est généralement placée :

* en haut du fichier
* ou dans un fichier d’en-tête (`.h`)

### Exemple complet

```c
#include <stdio.h>

int carre(int x);

int main(void)
{
    printf("%d\n", carre(4));
    return 0;
}

int carre(int x)
{
    return x * x;
}
```

---

## Les paramètres et arguments

* **Paramètres** : variables définies en entrée de la fonction
* **Arguments** : valeurs ou varaibles passées lors de l’appel à la fonction

```c
int multiplier(int a, int b)
{
    return a * b;
}

int resultat = multiplier(3, 5);
```

En C, les paramètres sont passés **par valeur**.


### Passage par valeur

Lorsqu’une variable est passée à une fonction, une **copie** est utilisée.

```c
void incrementer(int x)
{
    x = x + 1;
}

int main(void)
{
    int a = 5;
    incrementer(a);
    printf("%d\n", a); // affiche 5
}
```

La variable originale n’est pas modifiée.


### Fonctions sans paramètres et/ou sans retour

#### Sans paramètre

```c
void afficher_message(void)
{
    printf("Bienvenue !\n");
}
```

#### Sans valeur de retour

Le type `void` indique qu’aucune valeur n’est retournée.

```c
void dire_bonjour(void)
{
    printf("Bonjour\n");
}
```

---

## 8. La directive `return`

* Termine **immédiatement** l’exécution de la fonction
* Peut retourner une valeur (sauf pour `void`)

```c
int signe(int x)
{
    if (x > 0)
        return 1;
    if (x < 0)
        return -1;
    return 0;
}
```

---

## 9. Bonnes pratiques

* Donner des noms explicites aux fonctions
* Une fonction = une responsabilité
* Limiter la taille des fonctions
* Déclarer les fonctions avant leur utilisation

---

## Exercices

### Exercice 1

Écrire une fonction `max(int a, int b)` qui retourne le plus grand des deux nombres.

### Exercice 2

Écrire une fonction `est_pair(int n)` qui retourne 1 si le nombre est pair, 0 sinon.

### Exercice 3

Écrire une fonction `afficher_carre(int n)` qui affiche les carrés des nombres de 1 à `n`.

---

## À retenir

* Une fonction est un bloc de code réutilisable
* `main` est une fonction comme les autres
* Les paramètres sont passés par valeur
* `void` signifie "aucun"