Guide des Opérateurs Divers en C : Un Guide Amical pour les Débutants

Salut à toi, futur.e programmeur.euse ! Aujourd'hui, nous allons entreprendre un voyage passionnant à travers le monde des opérateurs divers du C. Ne t'inquiète pas si tu es nouveau dans le monde de la programmation – je serai ton guide amical, expliquant tout pas à pas. Alors, mettons-nous en route !

L'Opérateur sizeof en C

Imagine que tu empaques pour un voyage et que tu veux savoir combien d'espace chaque article prend. C'est essentiellement ce que fait l'opérateur sizeof en C – il nous dit la taille des choses dans notre programme !

L'opérateur sizeof renvoie la taille (en octets) de son opérande. Voici comment tu peux l'utiliser :

#include <stdio.h>

int main() {
int number = 42;
char letter = 'A';

printf("Taille de int: %zu octets\n", sizeof(int));
printf("Taille de char: %zu octets\n", sizeof(char));
printf("Taille de la variable number: %zu octets\n", sizeof(number));
printf("Taille de la variable letter: %zu octets\n", sizeof(letter));

return 0;
}

Lorsque tu exécutes ce code, tu verras quelque chose comme :

Taille de int: 4 octets
Taille de char: 1 octet
Taille de la variable number: 4 octets
Taille de la variable letter: 1 octet

Comme tu peux le voir, sizeof peut être utilisé avec à la fois des types de données et des variables. C'est super utile lorsque tu as besoin de savoir exactement combien de mémoire tes données utilisent !

L'Opérateur d'Adresse en C

Maintenant, parlons de l'opérateur d'adresse, représenté par l'ampersand (&). Pense à la mémoire de ton ordinateur comme un grand immeuble d'appartements. Chaque appartement (emplacement mémoire) a son propre adresse. L'opérateur & nous aide à trouver ces adresses !

Voici un exemple simple :

#include <stdio.h>

int main() {
int age = 25;
printf("Valeur de age: %d\n", age);
printf("Adresse de age: %p\n", (void*)&age);

return 0;
}

Cela affichera quelque chose comme :

Valeur de age: 25
Adresse de age: 0x7ffd5e7e9994

L'adresse exacte sera différente sur ton ordinateur, mais tu as l'idée !

L'Opérateur de Déréférencement en C

Si l'opérateur d'adresse (&) est à propos de trouver où quelque chose vit, l'opérateur de déréférencement (*) est à propos de visiter cette adresse et de voir ce qu'il y a dedans. C'est comme dire, "J'ai cette adresse, qu'y a-t-il à l'intérieur ?"

Voyons-le en action :

#include <stdio.h>

int main() {
int cookies = 5;
int *p_cookies = &cookies;

printf("Valeur de cookies: %d\n", cookies);
printf("Adresse de cookies: %p\n", (void*)&cookies);
printf("Valeur de p_cookies: %p\n", (void*)p_cookies);
printf("Valeur à *p_cookies: %d\n", *p_cookies);

return 0;
}

Sortie :

Valeur de cookies: 5
Adresse de cookies: 0x7ffd5e7e9994
Valeur de p_cookies: 0x7ffd5e7e9994
Valeur à *p_cookies: 5

Vois comment *p_cookies nous donne la valeur stockée à l'adresse pointée par p_cookies ? C'est le déréférencement en action !

L'Opérateur Ternaire en C

L'opérateur ternaire est comme une forme abrégée de l'instruction if-else. C'est parfait lorsque tu veux affecter une valeur en fonction d'une condition. Voici la syntaxe :

condition ? valeur_si_vrai : valeur_si_faux

Voyons un exemple :

#include <stdio.h>

int main() {
int age = 20;
char *status = (age >= 18) ? "adulte" : "mineur";

printf("À %d, tu es un %s.\n", age, status);

return 0;
}

Sortie :

À 20, tu es un adulte.

C'est génial, non ? C'est comme poser une question et obtenir l'un des deux possibles réponses !

L'Opérateur Point (.) en C

L'opérateur point est utilisé pour accéder aux membres d'une structure. Pense à une structure comme un conteneur qui peut contenir plusieurs éléments de différents types.

Voici un exemple :

#include <stdio.h>

struct Person {
char name[50];
int age;
};

int main() {
struct Person john = {"John Doe", 30};

printf("Nom: %s\n", john.name);
printf("Âge: %d\n", john.age);

return 0;
}

Sortie :

Nom: John Doe
Âge: 30

Nous utilisons l'opérateur point pour accéder à name et age de notre structure Person.

L'Opérateur d'Indirection en C

L'opérateur d'indirection est en réalité le même que l'opérateur de déréférencement (*) que nous avons discuté précédemment. Il est appelé "indirection" parce qu'il nous permet d'accéder indirectement à une valeur via un pointeur.

Voici un exemple légèrement plus complexe :

#include <stdio.h>

int main() {
int x = 10;
int *p = &x;
int **pp = &p;

printf("Valeur de x: %d\n", x);
printf("Valeur de *p: %d\n", *p);
printf("Valeur de **pp: %d\n", **pp);

return 0;
}

Sortie :

Valeur de x: 10
Valeur de *p: 10
Valeur de **pp: 10

Ici, nous utilisons plusieurs niveaux d'indirection. pp est un pointeur vers un pointeur !

Et voilà ! Nous avons couvert tous les opérateurs divers en C. Souviens-toi, la pratique rend parfait, donc n'ayez pas peur d'expérimenter avec ces opérateurs dans votre propre code. Bonne programmation !

Credits: Image by storyset