instructions

README.md

@@ -3,7 +3,7 @@
 > [!NOTE]
 > Le langage C reste aujourd'hui très utilisé, notamment pour le développement du noyau des systèmes d'exploitation, des logiciels embarqués et des applications nécessitant des performances élevées. Sa simplicité, sa proximité avec le matériel et sa portabilité sont les principales raisons de son succès durable.
 
-- [Histoire du langage C](histoire)
+- [Histoire du langage C](histoire.md)
 
 ## Caractéristiques
 
@@ -44,3 +44,9 @@ Sa syntaxe de base a inspiré de nombreux langages plus récents dont C++, Java
 - [Opérateurs arithmétiques](opérateurs/arithmétiques.md)
 - [Opérateurs logiques](opérateurs/logique.md)
 - [Opérateurs bit à bit](opérateurs/bit.md)
+
+### Les instructions
+
+- [Instructions conditionnelles](instructions/conditions.md)
+- [Instructions de boucles](instructions/boucles.md)
+- [Instructions de débranchement](instructions/debranchement.md)

instructions/boucles.md

@@ -0,0 +1,76 @@
+---
+title: Instructions conditionnelles
+---
+
+Les instructions de boucles en C permettent de répéter l'exécution d'un bloc de code tant qu'une condition donnée est vraie. Elles sont particulièrement utiles lorsque vous avez besoin d'exécuter plusieurs fois le même code ou un ensemble d'instructions. 
+
+## while
+
+L'instruction while exécute un bloc de code tant qu'une condition est vraie. La condition est vérifiée avant chaque itération, donc si elle est fausse au départ, le bloc de code n'est jamais exécuté.
+
+```c
+int i = 0;
+while (i < 5) {
+  printf("%d\n", i);
+  i++;
+}
+```
+
+## do-while
+
+L'instruction do-while est similaire à while, mais la différence principale est que la condition est vérifiée **après** l'exécution du bloc de code. Cela garantit que le bloc de code est exécuté **au moins une fois**, même si la condition est fausse dès le début.
+
+```c
+int i = 0;
+do {
+  printf("%d\n", i);
+  i++;
+} while (i < 5);
+```
+
+## for
+
+L'instruction for est souvent utilisée lorsque le nombre d'itérations est connu à l'avance. Elle permet d'initialiser une variable, de définir une condition, et d'incrémenter ou de décrémenter la variable dans une seule ligne de code.
+
+```c
+for (initialisation; condition; opération) {
+    // Code à exécuter tant que la condition est vraie
+}
+```
+
+## Boucle infinie
+
+Une boucle infinie est une boucle qui ne se termine jamais parce que sa condition est toujours vraie. Les boucles infinies peuvent être utiles dans certains contextes, comme les serveurs ou les systèmes embarqués qui doivent toujours fonctionner jusqu'à ce qu'une interruption externe survienne.
+
+```c
+while (1) {
+    // Cette boucle ne se terminera jamais
+}
+```
+
+ou
+
+```c
+for (;;) {
+    // Cette boucle ne se terminera jamais
+}
+```
+
+## Sortir des boucles
+
+Il est possible de contrôler le comportement des boucles avec les [instructions de débranchement](debranchement) :
+
+- break : Pour sortir immédiatement de la boucle.
+- continue : Pour sauter à l'itération suivante sans exécuter le reste du bloc de code.
+
+## Boucles imbriquées
+
+Il est possible d'imbriquer des boucles, c'est-à-dire de placer une boucle à l'intérieur d'une autre. Cela est souvent utilisé pour parcourir des structures de données en plusieurs dimensions comme des tableaux.
+
+```c
+for (int i = 0; i < 3; i++) {
+  for (int j = 0; j < 3; j++) {
+    printf("i = %d, j = %d\n", i, j);
+  }
+}
+```

instructions/conditions.md

@@ -0,0 +1,65 @@
+# Instructions conditionnelles
+
+> Les instructions conditionnelles en C permettent d'exécuter des blocs de code spécifiques en fonction de conditions. Elles permettent de prendre des décisions logiques dans un programme.
+
+## if
+
+L'instruction _if_ permet d'exécuter un bloc de code uniquement si une condition est vraie.
+
+```c
+int a = 10;
+
+if (a > 5) {
+  printf("a est supérieur à 5.\n");
+}
+```
+
+## else
+
+L'instruction _else_ permet de définir un bloc de code qui sera exécuté si la condition du if est fausse.
+
+```c
+int a = 3;
+
+if (a > 5) {
+  printf("a est supérieur à 5.\n");
+} else {
+  printf("a est inférieur ou égal à 5.\n");
+}
+```
+
+## else if
+
+L'instruction _else if_ permet de tester une nouvelle condition si la première _if_ est fausse.
+
+```c
+int a = 8;
+
+if (a > 10) {
+  printf("a est supérieur à 10.\n");
+} else if (a > 5) {
+  printf("a est supérieur à 5 mais inférieur ou égal à 10.\n");
+} else {
+  printf("a est inférieur ou égal à 5.\n");
+}
+
+```
+
+Voir les [opérateurs de comparaison](../opérateurs/comparaison) et les [opérateurs logiques](../opérateurs/logique).
+
+## switch
+
+L'instruction switch est une alternative aux multiples else if. Elle compare une variable avec différentes valeurs possibles et exécute le code correspondant.
+
+```c
+switch (variable) {
+case valeur1:
+  // Code si variable == valeur1
+  break;
+case valeur2:
+  // Code si variable == valeur2
+  break;
+default:
+  // Code si aucune correspondance
+}
+```

instructions/debranchement.md

@@ -0,0 +1,53 @@
+# Instructions de débranchement
+
+## break
+
+L'instruction break permet de quitter immédiatement une boucle (for, while, do-while) ou une structure switch. Dès que le programme rencontre un break, il sort du bloc de code en cours.
+
+```c
+for (int i = 0; i < 10; i++) {
+    if (i == 5) {
+        break;  // Sort de la boucle dès que i vaut 5
+    }
+    printf("%d\n", i);
+}
+```
+
+Le break permet ici de sortir du bloc switch après avoir exécuté le code correspondant à la valeur testée
+
+## continue
+
+L'instruction continue permet de sauter à l'itération suivante d'une boucle, sans terminer l'exécution du bloc de code courant.
+
+```c
+for (int i = 0; i < 10; i++) {
+  if (i == 5) {
+    continue;  // Saute l'itération lorsque i vaut 5
+  }
+  printf("%d\n", i);
+}
+```
+
+## return
+
+L'instruction return permet de quitter une fonction et de retourner une valeur (si la fonction n'est pas de type void). Elle interrompt l'exécution de la fonction en cours et retourne éventuellement une valeur à la fonction appelante.
+
+## goto
+
+L'instruction goto permet de sauter directement à une autre partie du programme marquée par une étiquette (label). Son utilisation est généralement déconseillée car elle rend le code difficile à suivre et à maintenir. Cependant, dans certains cas spécifiques, elle peut être utile pour sortir de plusieurs niveaux d'imbrication ou dans la gestion de sortie d'erreur.
+
+Une étiquette se définie avec un nom suivi d'un caractère `:`. Normalement, une étiquette est placée en colonne 0 du fichier de texte.
+
+Pour les autres instructions, les choses sont contrôlée par le compilateur, mais ce qui n'est pas le cas avec goto. Effectivement, si l'étiquette de destination n'est pas placée dans le même bloc que l'instruction goto, alors vous pouvez désynchroniser la pile d'exécution et donc aboutir à un crash de l'application. C'est pour cette raison qu'il est très fortement conseillé de ne pas utiliser l'instruction goto au profit des autres instructions.
+
+```c
+int a = 10;
+if (a > 5) {
+  goto fin;  // Saute directement à l'étiquette "fin"
+}
+
+printf("Ce message ne sera pas affiché.\n");
+
+fin:
+  printf("Fin du programme.\n");
+```