C - Opérateurs :Votre Porte d'Entrée vers la Magie de la Programmation

Bonjour à tous, futurs sorciers de la programmation ! ? Je suis ravi d'être votre guide dans cette aventure passionnante dans le monde de la programmation en C. Aujourd'hui, nous allons explorer le royaume magique des opérateurs en C. Ne vous inquiétez pas si vous n'avez jamais écrit une ligne de code avant – nous commencerons desde le début et nous avancerons ensemble.

Opérateurs Arithmétiques : Les Sortilèges de Base

Commençons par les sortilèges les plus simples de notre grimoire de programmation – les opérateurs arithmétiques. Ce sont les briques de base de la plupart des calculs en C.

Les Cinq Fabuleux de l'Arithmétique

Voici les cinq opérateurs arithmétiques de base :

Opérateur	Nom	Exemple
+	Addition	5 + 3 = 8
-	Soustraction	7 - 2 = 5
*	Multiplication	4 * 6 = 24
/	Division	10 / 2 = 5
%	Modulo (Reste)	7 % 3 = 1

Voyons ces opérateurs en action :

#include <stdio.h>

int main() {
int a = 10, b = 3;

printf("Addition : %d\n", a + b);
printf("Soustraction : %d\n", a - b);
printf("Multiplication : %d\n", a * b);
printf("Division : %d\n", a / b);
printf("Modulo : %d\n", a % b);

return 0;
}

Lorsque vous exécutez ce code, vous verrez :

Addition : 13
Soustraction : 7
Multiplication : 30
Division : 3
Modulo : 1

Remarquez comment la division nous donne 3 au lieu de 3.33 ? C'est parce que lorsque nous divisons des entiers en C, nous obtenons un résultat entier. L'opérateur modulo (%) nous donne le reste après la division.

Opérateurs Relationnels : Comparer des Pommes et des Oranges

Maintenant que nous pouvons faire de la basic math, apprenons à comparer des choses. Les opérateurs relationnels sont comme les juges dans un concours de talents – ils comparent deux valeurs et nous disent comment elles se rapportent l'une à l'autre.

Voici notre alignement d'opérateurs relationnels :

Opérateur	Signification	Exemple
==	Égal à	5 == 5 est vrai
!=	Non égal à	5 != 3 est vrai
>	Supérieur à	7 > 3 est vrai
<	Inférieur à	2 < 8 est vrai
>=	Supérieur ou égal à	5 >= 5 est vrai
<=	Inférieur ou égal à	4 <= 4 est vrai

Voyons comment utiliser ces opérateurs :

#include <stdio.h>

int main() {
int x = 5, y = 8;

printf("x == y : %d\n", x == y);
printf("x != y : %d\n", x != y);
printf("x > y : %d\n", x > y);
printf("x < y : %d\n", x < y);
printf("x >= y : %d\n", x >= y);
printf("x <= y : %d\n", x <= y);

return 0;
}

Ce code produira :

x == y : 0
x != y : 1
x > y : 0
x < y : 1
x >= y : 0
x <= y : 1

En C, 0 signifie faux, et toute valeur non nulle (souvent 1) signifie vrai. Donc, nous pouvons voir que 5 n'est pas égal à 8 et qu'il est inférieur à 8.

Opérateurs Logiques : Les Décideurs

Les opérateurs logiques sont comme les sages de notre village de programmation. Ils nous aident à prendre des décisions complexes en combinant des conditions plus simples.

Voici nos opérateurs logiques :

Opérateur	Signification	Exemple
&&	ET	(5 > 3) && (4 < 7) est vrai
||	OU	(5 > 8) || (4 < 7) est vrai
!	NON	!(5 > 8) est vrai

Voyons comment ces opérateurs fonctionnent :

#include <stdio.h>

int main() {
int a = 5, b = 3, c = 8;

printf("(a > b) && (c > a) : %d\n", (a > b) && (c > a));
printf("(a > b) || (a > c) : %d\n", (a > b) || (a > c));
printf("!(a > b) : %d\n", !(a > b));

return 0;
}

Ce code produira :

(a > b) && (c > a) : 1
(a > b) || (a > c) : 1
!(a > b) : 0

L'opérateur ET (&&) renvoie vrai seulement si les deux conditions sont vraies. L'opérateur OU (||) renvoie vrai si au moins une condition est vraie. L'opérateur NON (!) inverse la valeur de vérité.

Opérateurs Bit à Bit : Les Magiciens Binaires

Maintenant, nous entrons dans le royaume de la magie binaire. Les opérateurs bit à bit travaillent directement avec les représentations binaires des nombres. Ils sont comme les microscopes du monde de la programmation, nous permettant de voir et de manipuler des bits individuels.

Voici nos opérateurs bit à bit :

Opérateur	Nom	Exemple
&	ET bit à bit	5 & 3 = 1
|	OU bit à bit	5 | 3 = 7
^	OU exclusif bit à bit	5 ^ 3 = 6
~	NON bit à bit	~5 = -6
<<	Décalage à gauche	5 << 1 = 10
>>	Décalage à droite	5 >> 1 = 2

Voyons ces opérateurs en action :

#include <stdio.h>

int main() {
unsigned int a = 5, b = 3;  // 5 est 101 en binaire, 3 est 011

printf("a & b = %u\n", a & b);   // 101 & 011 = 001
printf("a | b = %u\n", a | b);   // 101 | 011 = 111
printf("a ^ b = %u\n", a ^ b);   // 101 ^ 011 = 110
printf("~a = %d\n", ~a);         // ~101 = ...11111010 (complément à deux)
printf("a << 1 = %u\n", a << 1); // 101 devient 1010
printf("a >> 1 = %u\n", a >> 1); // 101 devient 10

return 0;
}

Ce code produira :

a & b = 1
a | b = 7
a ^ b = 6
~a = -6
a << 1 = 10
a >> 1 = 2

Ces opérateurs sont particulièrement utiles lorsque vous travaillez sur des programmations de bas niveau ou avez besoin d'optimiser votre code.

Opérateurs d'Affectation : Les Changeurs de Valeur

Les opérateurs d'affectation sont comme les scribes de notre monde de programmation. Ils écrivent (ou affectent) des valeurs aux variables. Rencontrons nos opérateurs d'affectation :

Opérateur	Exemple	Équivalent à
=	x = 5	x = 5
+=	x += 3	x = x + 3
-=	x -= 2	x = x - 2
*=	x *= 4	x = x * 4
/=	x /= 2	x = x / 2
%=	x %= 3	x = x % 3
<<=	x <<= 2	x = x << 2
>>=	x >>= 1	x = x >> 1
&=	x &= 3	x = x & 3
^=	x ^= 5	x = x ^ 5
|=	x |= 3	x = x | 3

Voici un exemple rapide :

#include <stdio.h>

int main() {
int x = 10;

x += 5;  // x est maintenant 15
printf("Après x += 5 : %d\n", x);

x *= 2;  // x est maintenant 30
printf("Après x *= 2 : %d\n", x);

x %= 7;  // x est maintenant 2 (30 % 7 = 2)
printf("Après x %%= 7 : %d\n", x);

return 0;
}

Ce code produira :

Après x += 5 : 15
Après x *= 2 : 30
Après x %%= 7 : 2

Ces opérateurs sont des raccourcis qui rendent notre code plus concis et souvent plus lisible.

Opérateurs Divers : Les Forces Spéciales

Maintenant, rencontrons quelques opérateurs spéciaux qui ne rentrent pas dans nos autres catégories.

Opérateur sizeof

L'opérateur sizeof nous dit la taille d'une variable ou d'un type de données en octets. Il est comme une règle pour nos données.

#include <stdio.h>

int main() {
int x;
char c;
float f;

printf("Taille de int : %zu octets\n", sizeof(x));
printf("Taille de char : %zu octet\n", sizeof(c));
printf("Taille de float : %zu octets\n", sizeof(f));

return 0;
}

Ce code pourrait produire (en fonction de votre système) :

Taille de int : 4 octets
Taille de char : 1 octet
Taille de float : 4 octets

Opérateur Ternaire

L'opérateur ternaire est comme une version compacte de l'instruction if-else. Il est écrit sous la forme condition ? valeur_si_vrai : valeur_si_faux.

#include <stdio.h>

int main() {
int x = 10;
int y = (x > 5) ? 1 : 0;

printf("y = %d\n", y);

return 0;
}

Ce code produira :

y = 1

Parce que x est supérieur à 5, y est affecté à la valeur 1.

Priorité des Opérateurs en C : La Hiérarchie

Juste comme en mathématiques, C a une hiérarchie des opérations. Cette hiérarchie détermine lesquelles des opérations sont effectuées en premier lorsque plusieurs opérateurs sont utilisés dans une seule expression.

Voici une table simplifiée de priorité, de la plus haute à la plus basse :

Priorité	Opérateur
1	() [] -> .
2	! ~ ++ -- + - * & (type) sizeof
3	* / %
4	+ -
5	<< >>
6	< <= > >=
7	== !=
8	&
9	^
10	|
11	&&
12	||
13	?:
14	= += -= *= /= %= &= ^= |= <<= >>=
15	,

N'oubliez pas, lorsque vous avez des doutes, utilisez des parenthèses pour rendre vos intentions claires !

Autres Opérateurs en C : Les Joyaux Cachés

Il y a encore quelques opérateurs en C que nous n'avons pas couverts encore :

1. L'opérateur virgule (,): Il permet d'utiliser plusieurs expressions là où seulement une est attendue.
2. L'opérateur d'adresse (&): Il renvoie l'adresse mémoire d'une variable.
3. L'opérateur de déréférencement (*): Il accède à la valeur à une adresse mémoire particulière.
4. L'opérateur de membre de structure (.): Il accède aux membres d'une structure.
5. L'opérateur de pointeur de structure (->): Il accède aux membres d'une structure à travers un pointeur.

Nous explorerons ces opérateurs en plus de détail lorsque nous plongerons dans les pointeurs et les structures dans les leçons futures.

Et voilà, mes jeunes apprentis de codage ! Nous avons parcouru le pays des opérateurs en C, des sorts arithmétiques aux incantations bitwise complexes. Souvenez-vous, la pratique fait le maître, donc n'hésitez pas à expérimenter avec ces opérateurs dans votre propre code. Bon codage, et que les bits soient toujours en votre faveur ! ?‍♂️?

Credits: Image by storyset