Opérateurs

README.md

@@ -1,3 +1,5 @@
+# Langage C
+
 > [!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.
 
@@ -6,7 +8,7 @@
 ## Caractéristiques
 
 - Langage de programmation **procédural** ;
-- Langage de bas niveau : conçu pour être compilé en un nombre d'instructions machine prévisible en termes d'occupation mémoire et de charges de calcul ;
+- Langage de **bas niveau** : conçu pour être compilé en un nombre d'instructions machine prévisible en termes d'occupation mémoire et de charges de calcul ;
 - Langage extrêmement utilisé dans :
   - La programmation embarquée sur micro-contrôleurs ;
   - Les calculs intensifs ;
@@ -21,7 +23,7 @@ Sa syntaxe de base a inspiré de nombreux langages plus récents dont C++, Java
 - Nombre restreint de mots clés, ce qui facilite l'apprentissage ;
 - Proche de la machine : opérateurs proches du langage machines et fonctions permettant un accès direct au système ;
 - Programmation modulaire : permet de gérer plusieurs fichiers sources ⇒ structuration, compréhensibilité et réutilisation du code ;
-- Grand nombre de bibliothèques tierces existantes.
+- Grand nombre de **bibliothèques tierces** existantes.
 
 ### Inconvénients
 
@@ -32,6 +34,13 @@ Sa syntaxe de base a inspiré de nombreux langages plus récents dont C++, Java
 
 ## Concepts
 
-- [Anatomie d'un programme](anatomie)
+- [Anatomie d'un programme](anatomie.md)
-- [La compilation](compilation)
+- [La compilation](compilation.md)
-- [Les variables](variables)
+- [Les variables](variables.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 bit à bit](opérateurs/bit.md)

opérateurs/affectation.md

@@ -0,0 +1,23 @@
+# Opérateurs d'affectation
+
+Les opérateurs d'affectation en C sont utilisés pour assigner des valeurs à des variables. Le plus basique est l'opérateur =, mais il existe plusieurs autres opérateurs d'affectation combinés qui effectuent des opérations mathématiques tout en affectant une valeur à la variable.
+
+Opérateur |	Description |	Opérateur | Équivalence
+---|---|---|---
+=	| Opérateur d'affectation simple. Attribue les valeurs des opérandes de droite à l'opérande de gauche c = a + b attribuera la valeur de a + b à c
++=	| Addition et affectation |	a += 5 | a = a + 5
+-=	| Soustraction et affectation	| a -= 5 | a = a - 5
+*=	| Miltiplication et affectation	| a *= 5 | a = a * 5
+/=	| Division et affectation	| a /= 5 | a = a / 5
+%=	| Modulo et affectation	| a %= 5 | a = a % 5
+<<=	| Décallage à gauche et affectation	| a <<= 2 | a = a << 2
+\>>=	| Décallage à droite et affectation	| a >>= 2 | a = a >> 2
+&=	| Et binaire et affectation	| a &= 2 | a = a & 2
+^=	| Ou exclusif et affectation	| a ^= 2 | a = a ^ 2
+\|=	| Ou binaire et affectation	| a \|= 2 | a = a | 2
+
+
+> Les opérateurs d'affection combinent l'affectation simple aux autre opérateurs pour simplifier l'écriture d'une formule.
+{class=definition}
+
+Chapitre suivant : les [Opérateurs arithmétiques](arithmétiques)

opérateurs/arithmétiques.md

@@ -0,0 +1,93 @@
+# Opérateurs arithmétiques
+
+Les opérateurs arithmétiques en C sont utilisés pour effectuer des opérations mathématiques de base telles que l'addition, la soustraction, la multiplication.
+
+### Addition (+)
+
+```c
+int a = 5, b = 3;
+int result = a + b;  // result vaut 8
+```
+
+### Soustraction (-)
+
+```c
+int a = 5, b = 3;
+int result = a - b;  // result vaut 2
+```
+
+### Multiplication (*)
+
+```c
+int a = 5, b = 3;
+int result = a * b;  // result vaut 15
+```
+
+### Division (/)
+
+```c
+int a = 10, b = 2;
+int result = a / b;  // result vaut 5
+```
+
+#### Remarque
+
+Lorsque les deux opérandes sont des entiers, la division entière est effectuée, ce qui signifie que toute fraction est ignorée (tronquée).
+
+```c
+int a = 10, b = 3;
+int result = a / b;  // result vaut 3 (10 / 3 = 3.333, mais la partie décimale est ignorée)
+```
+
+Si l'une des valeurs est de type flottant (comme float ou double), la division produira un résultat décimal.
+
+### Modulo (%)
+
+L'opérateur de modulo renvoie le reste de la division entière entre deux valeurs. Cet opérateur ne peut être utilisé qu'avec des entiers.
+
+```c
+int a = 10, b = 3;
+int result = a % b;  // result vaut 1 (car 10 % 3 = 1)
+```
+
+Opérateurs d'incrémentation et de décrémentation
+
+Ces opérateurs sont des variantes des opérateurs arithmétiques, utilisés pour ajouter ou soustraire 1 à une variable.
+
+### Incrémentation
+
+L'opérateur d'incrémentation ajoute 1 à la valeur de la variable.
+
+Post-incrémentation (var++) : L'opérateur incrémente la variable après que sa valeur actuelle soit utilisée dans l'expression.
+
+```c
+int a = 5;
+int result = a++;  // result vaut 5, puis a devient 6
+```
+
+Pré-incrémentation (++var) : L'opérateur incrémente la variable avant que sa valeur soit utilisée dans l'expression.
+
+```c
+int a = 5;
+int result = ++a;  // a devient 6, puis result vaut 6
+```
+
+### Décrémentation (--)
+
+L'opérateur de décrémentation soustrait 1 à la valeur de la variable.
+
+Post-décrémentation (var--) : La décrémentation est effectuée après que la valeur de la variable soit utilisée dans l'expression.
+
+```c
+int a = 5;
+int result = a--;  // result vaut 5, puis a devient 4
+```
+
+Pré-décrémentation (--var) : La décrémentation est effectuée avant que la valeur soit utilisée dans l'expression.
+
+```c
+int a = 5;
+int result = --a;  // a devient 4, puis result vaut 4
+```
+
+Chapitre suivant : les [Opérateurs logique](logique)

opérateurs/bit.md

@@ -0,0 +1,65 @@
+# Opérateurs bit-à-bit
+
+Les opérateurs bit-à-bit travaillent sur chacun des bits des opérandes.
+
+## Inversion bit-à-bit
+
+L'opérateur `~` retourne 0 pour un bit à 1 et 1 pour un bit à 0. C'est un opérateur unaire
+
+ v   | r   | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0
+-----|----:|--:|--:|--:|--:|--:|--:|--:|--:
+a    |  73 | 0 | 1 | 0 | 0 | 1 | 0 | 0 | 1
+~a   | 182 | 1 | 0 | 1 | 1 | 0 | 1 | 1 | 0
+
+
+## ET bit-à-bit
+
+L'opérateur `&` retourne 1 si les deux bits de même poids sont à 1
+
+ v    | r |  7  | 6  | 5  | 4  | 3  | 2  | 1 | 0
+------|--:|--:|--:|--:|--:|--:|--:|--:|--:
+a     | 73 | 0  | 1  | 0  | 0  | 1  | 0  | 0  | 1
+b     | 15 | 0  | 0  | 0  | 0  | 1  | 1  | 1  | 1
+a & b |  9 | 0  | 0  | 0  | 0  | 1  | 0  | 0  | 1
+
+
+## OU bit-à-bit
+
+L'opérateur `|` retourne 1 si l'un ou l'autre des deux bits de même poids est à 1 (ou les deux).
+
+ v | r |  7  | 6  | 5  | 4  | 3  | 2  | 1 | 0
+---|--:|--:|--:|--:|--:|--:|--:|--:|--:
+a      | 73 | 0  | 1  | 0  | 0  | 1  | 0  | 0  | 1
+b      | 15 | 0  | 0  | 0  | 0  | 1  | 1  | 1  | 1
+a \| b | 79 | 0  | 1  | 0  | 0  | 1  | 1  | 1  | 1
+
+
+## OU exclusif bit-à-bit
+
+L'opérateur `^` retourne 1 si un seul des deux bits de même poids est à 1.
+
+ v | r |  7  | 6  | 5  | 4  | 3  | 2  | 1 | 0
+---|--:|--:|--:|--:|--:|--:|--:|--:|--:
+a      | 73 | 0  | 1  | 0  | 0  | 1  | 0  | 0  | 1
+b      | 15 | 0  | 0  | 0  | 0  | 1  | 1  | 1  | 1
+a ^ b  | 70 | 0  | 1  | 0  | 0  | 0  | 1  | 1  | 0
+
+
+## Décalage à droite
+
+Un décalage à droite revient à efectuer un division entière par 2.
+
+ v | r |  7  | 6  | 5  | 4  | 3  | 2  | 1 | 0
+---|--:|--:|--:|--:|--:|--:|--:|--:|--:
+a      | 73 | 0  | 1  | 0  | 0  | 1  | 0  | 0  | 1
+a >> 2 | 18 | 0  | 0  | 0  | 1  | 0  | 0  | 1  | 0
+
+
+## Décalage à gauche
+
+Un décalage à gauche revient à efectuer une multiplication par 2.
+
+ v | r |  7  | 6  | 5  | 4  | 3  | 2  | 1 | 0
+-------|--:|--:|--:|--:|--:|--:|--:|--:|--:
+a      |  9 | 0  | 0  | 0  | 0  | 1  | 0  | 0  | 1
+a << 2 | 36 | 0  | 0  | 1  | 0  | 0  | 1  | 0  | 0

opérateurs/logique.md

@@ -0,0 +1,115 @@
+# Les opérateurs logiques
+
+Ces opérateurs permetent de vérifier si plusieurs conditions sont vraies. Les valeurs renvoyés sont 0 pour faux et 1 pour vrai.
+
+A noter : Par économie de moyens, le langage C travaille avec des entiers en utilisant la convention suivante : la valeur 0 représente la valeur booléenne faux ou false, et toute autre valeur sera assimilée à la valeur vrai ou true.
+
+### NON logique
+
+L'opérateur `!` inverse l'état d'une variable booléenne. Retourne la valeur 1 si la variable vaut 0 et 0 si elle vaut 1 (ou tout nombre différent de 0).
+
+```c
+a = !b;
+```
+
+a  | !a
+--:|--:
+0  | 1
+1  | 0
+
+### OU logique
+
+> L'opérateur **OU logique** vérifie qu'au moins **une** des conditions est réalisée.
+{class=definition}
+
+L'opérateur `||` retourne 1 si une des deux conditions a la valeur 1 (ou tout nombre différent de 0).
+
+L'opérateur `||` retourne 0 seulement si les deux conditions ont la valeur 0.
+
+```c
+condition1 || condition2;
+```
+
+a  | b  | a \|\| b
+--:|--:|--:
+0  | 0 |  0
+1  | 0 |  1
+0  | 1 |  1
+1  | 1 |  1
+
+
+### ET logique
+
+> L'opérateur **ET logique** vérifie que **toutes** les conditions sont vraies.
+{class=definition}
+
+L'opérateur `&&` retourne 1 seulement si les deux conditions ont la valeur 1 (ou tout nombre différent de 0).
+
+L'opérateur `&&` retourne 0 si **une seule** des deux conditions possède la valeur 0 et quelque soit la valeur de l'autre condition.
+
+```c
+resultat = condition1 && condition2;
+```
+
+a  | b  | a && b
+--:|--:|--:
+0  | 0 |  0
+1  | 0 |  0
+0  | 1 |  0
+1  | 1 |  1
+
+
+### Short-circuit evaluation
+
+Short-circuit evaluation (court-circuit d'évaluation) ou lazy evaluation (évaluation paresseuse) ou appel par nécessité ou évaluation retardée est un mécanisme d'optimisation de l'éxecution du programme. Les expressions ne sont évaluées que si c'est nécessaire au résultat final.
+
+Si le résultat est irrémédiablement connu à une étape alors la suite n'est pas évaluée car cela ne pourra faire changer le résultat.
+
+Soit les 3 fonctions suivantes
+
+```c
+int FonctionV()
+{
+  puts("Execution de V");
+  return 1;
+}
+
+int FonctionF()
+{
+  puts("Execution de F");
+  return 0;
+}
+
+int FonctionA()
+{
+  puts("Execution de A");
+  return 0;
+}
+```
+
+```c
+FonctionV() && FonctionA();
+```
+
+`FonctionA` est appelée car la seule évaluation de `FonctionV` qui retourne vrai ne permet pas de conclure au résultat.
+
+```c
+FonctionF() && FonctionA();
+```
+
+Il n'est pas nécessaire d'appeler `FonctionA` car de toute façon avec `FonctionF` qui retourne faux le résultat final sera faux quelque soit le résultat de `FonctionA`.
+
+Le court-circuit d'évaluation peut remplacer une syntaxe utilisant `if`
+
+```c
+if (FonctionB())
+{
+  FonctionA();
+}
+```
+
+```c
+FonctionB() && FonctionA();
+```
+
+Chapitre suivant : les [Opérateurs bit-à-bit](bit)