diff --git a/README.md b/README.md
index f71c318..c0d6b65 100644
--- a/README.md
+++ b/README.md
@@ -37,14 +37,16 @@ Sa syntaxe de base a inspiré de nombreux langages plus récents dont C++, Java
 - [Anatomie d'un programme](anatomie.md)
 - [La compilation](compilation.md)
 - [Les variables](variables.md)
+- [Les fonctions](fonctions.md)
 
 ### Opérateurs
 
 - [Opérateurs d'affectation](opérateurs/affectation.md)
 - [Opérateurs arithmétiques](opérateurs/arithmétiques.md)
 - [Opérateurs logiques](opérateurs/logique.md)
-- [Opérateurs de comparaison](opérateurs/compataison.md)
+- [Opérateurs relationnels](opérateurs/comparaison.md)
 - [Opérateurs bit à bit](opérateurs/bit.md)
+- [Priorité des opérations](opérateurs/priorite.md)
 
 ### Les instructions
 
diff --git a/fonctions.md b/fonctions.md
new file mode 100644
index 0000000..766010d
--- /dev/null
+++ b/fonctions.md
@@ -0,0 +1,218 @@
+# 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"
diff --git a/opérateurs/priorite.md b/opérateurs/priorite.md
index 488599d..95fd795 100644
--- a/opérateurs/priorite.md
+++ b/opérateurs/priorite.md
@@ -8,8 +8,8 @@ Les opérateurs avec la plus haute priorité apparaissent en haut du tableau, ce
 
 Categorie | Opérateurs | Associativité
 ---            |---|---
-Préfixe        | () [] `->` `.` `++` `--`    | →
-Unaire         | `+` `-` `!` `~` `++` `--` (type)* & sizeof  | ←
+Préfixe        | `()` `[]` `->` `.` `++` `--` | →
+Unaire         | `+` `-` `!` `~` `++` `--` `(type)` `*` `&` `sizeof`  | ←
 Multiplicative | `*` `/` `%`      | →
 Additive       | `+` `-`        | →
 Décallage      | `<<` `>>`      | →
@@ -21,5 +21,5 @@ Ou binaire     | `\|`   | →
 Et logique     | `&&`   | →
 Ou logique     | `\|\|` | →
 Ternaire       | `?:`   |  ←
-Assignation    | = += -= *= /= %=>>= <<= &= ^= \|=  |←
-Séquence       | , | →
+Assignation    | `=` `+=` `-=` `*=` `/=` `%=` `>>=` `<<=` `&=` `^=` `\|=`  |←
+Séquence       | `,` | →