Opérateurs unaires en C

Bonjour à tous, futurs stars de la programmation ! Aujourd'hui, nous allons embarquer sur un voyage passionnant dans le monde des opérateurs unaires en C. Ne vous inquiétez pas si vous êtes nouveau en programmation – je serai votre guide amical et nous explorerons ce sujet étape par étape. Alors, prenez votre sac à dos virtuel et c'est parti !

L'Opérateur d'incrémentation en C

Commençons par l'opérateur d'incrémentation, qui est comme un bouton magique "+1" pour nos variables. En C, nous utilisons "++" pour incrémenter une valeur. C'est super pratique lorsque nous voulons compter des choses ou parcourir une séquence.

Il y a deux façons d'utiliser l'opérateur d'incrémentation :

1. Pré-incrémentation : ++variable
2. Post-incrémentation : variable++

Regardons quelques exemples :

#include <stdio.h>

int main() {
    int cookies = 5;

    printf("J'ai %d cookies.\n", cookies);

    // Pré-incrémentation
    printf("Après en avoir mangé un : %d\n", ++cookies);

    // Post-incrémentation
    printf("Compte actuel : %d\n", cookies++);
    printf("Après avoir compté : %d\n", cookies);

    return 0;
}

Sortie :

J'ai 5 cookies.
Après en avoir mangé un : 6
Compte actuel : 6
Après avoir compté : 7

Dans cet exemple, nous commençons avec 5 cookies. Lorsque nous utilisons la pré-incrémentation (++cookies), elle incrémente immédiatement la valeur avant de l'utiliser. Avec la post-incrémentation (cookies++), elle utilise la valeur actuelle d'abord, puis l'incrémente après.

L'Opérateur de décrémentation en C

Maintenant, rencontrons l'opérateur de décrémentation, le jumeau sournois de l'incrémentation. Il fait l'opposé – soustrait 1 à notre variable. Nous utilisons "--" pour cette opération.

tout comme son frère, il existe en deux saveurs :

1. Pré-décrémentation : --variable
2. Post-décrémentation : variable--

Regardons-le en action :

#include <stdio.h>

int main() {
    int vies = 3;

    printf("Vous avez %d vies.\n", vies);

    // Pré-décrémentation
    printf("Oups ! Vous en avez perdu une : %d\n", --vies);

    // Post-décrémentation
    printf("Vies actuelles : %d\n", vies--);
    printf("Game Over : %d\n", vies);

    return 0;
}

Sortie :

Vous avez 3 vies.
Oups ! Vous en avez perdu une : 2
Vies actuelles : 2
Game Over : 1

Ici, nous commençons avec 3 vies dans notre jeu imaginaire. La pré-décrémentation (--vies) réduit immédiatement le compteur, tandis que la post-décrémentation (vies--) utilise la valeur actuelle avant de la décrémenter.

L'Opérateur unaire "+" en C

L'opérateur unaire "+" peut sembler un peu redondant au début. Après tout, un nombre positif n'est-il pas déjà... positif ? Eh bien, oui, mais cet opérateur a ses utilisations, surtout lorsque l'on travaille avec différents types de données.

#include <stdio.h>

int main() {
    int num = 42;
    float pi = 3.14;

    printf("Entier positif : %d\n", +num);
    printf("Flottant positif : %f\n", +pi);

    return 0;
}

Sortie :

Entier positif : 42
Flottant positif : 3.140000

Dans cet exemple, l'opérateur unaire "+" ne change pas les valeurs, mais il garantit qu'elles sont traitées comme des nombres positifs. C'est comme donner un petit mot d'encouragement à vos variables : "Reste positif, mon pote !"

L'Opérateur unaire "-" en C

L'opérateur unaire "-" est comme une baguette magique qui transforme les nombres positifs en négatifs (et vice versa). Il est super utile lorsque nous avons besoin de basculer le signe d'une valeur.

#include <stdio.h>

int main() {
    int temperature = 25;
    float solde = -100.50;

    printf("Température originale : %d\n", temperature);
    printf("En dessous de zéro : %d\n", -temperature);

    printf("Solde original : %.2f\n", solde);
    printf("Dette épongée : %.2f\n", -solde);

    return 0;
}

Sortie :

Température originale : 25
En dessous de zéro : -25
Solde original : -100.50
Dette épongée : 100.50

Voyez comment nous avons transformé un jour chaud en un jour froid, et effacé notre dette avec juste un petit signe "-" ? C'est le pouvoir de l'opérateur unaire moins !

L'Opérateur d'adresse (&) en C

Maintenant, plongeons dans quelque chose de plus avancé – l'opérateur d'adresse. Ce petit esperluette (&) est comme un GPS pour nos variables, indiquant exactement où elles résident dans la mémoire de l'ordinateur.

#include <stdio.h>

int main() {
    int age = 25;
    float hauteur = 1.75;

    printf("Valeur de l'âge : %d\n", age);
    printf("Adresse de l'âge : %p\n", (void*)&age);

    printf("Valeur de la hauteur : %.2f\n", hauteur);
    printf("Adresse de la hauteur : %p\n", (void*)&hauteur);

    return 0;
}

Sortie (note : les adresses réelles varieront) :

Valeur de l'âge : 25
Adresse de l'âge : 0x7ffd5e8e3994
Valeur de la hauteur : 1.75
Adresse de la hauteur : 0x7ffd5e8e3998

Ici, nous ne regardons pas seulement les valeurs de nos variables, mais nous jetons également un œil à leurs repaires secrets en mémoire. Cool, non ?

L'Opérateur de déréférencement (*) en C

L'opérateur de déréférencement est comme une carte au trésor – il nous aide à trouver la valeur cachée à une adresse mémoire spécifique. C'est le pendant de notre opérateur d'adresse.

#include <stdio.h>

int main() {
    int trésor = 1000;
    int *carte = &trésor;

    printf("Valeur du trésor : %d\n", trésor);
    printf("La carte pointe vers : %p\n", (void*)carte);
    printf("Trésor trouvé : %d\n", *carte);

    *carte = 2000;  // Change le trésor !
    printf("Nouvelle valeur du trésor : %d\n", trésor);

    return 0;
}

Sortie :

Valeur du trésor : 1000
La carte pointe vers : 0x7ffd5e8e3994
Trésor trouvé : 1000
Nouvelle valeur du trésor : 2000

Dans cet exemple, notre 'carte' (pointeur) nous conduit au trésor, et nous pouvons même changer la valeur du trésor en utilisant l'opérateur de déréférencement. C'est comme de la magie !

L'Opérateur logique NOT (!) en C

L'opérateur logique NOT est comme un rebelle – il transforme vrai en faux et faux en vrai. En C, toute valeur non nulle est considérée comme vrai, et zéro est faux.

#include <stdio.h>

int main() {
    int ensoleillé = 1;  // 1 signifie vrai
    int pluvieux = 0;  // 0 signifie faux

    printf("Est-ce qu'il fait ensoleillé ? %d\n", ensoleillé);
    printf("Est-ce qu'il ne fait pas ensoleillé ? %d\n", !ensoleillé);

    printf("Est-ce qu'il fait pluvieux ? %d\n", pluvieux);
    printf("Est-ce qu'il ne fait pas pluvieux ? %d\n", !pluvieux);

    return 0;
}

Sortie :

Est-ce qu'il fait ensoleillé ? 1
Est-ce qu'il ne fait pas ensoleillé ? 0
Est-ce qu'il fait pluvieux ? 0
Est-ce qu'il ne fait pas pluvieux ? 1

Voyez comment notre opérateur logique NOT inverse les conditions météorologiques ? C'est comme avoir un bouton "jour de l'opposé" !

L'Opérateur de complément à 1 (~) en C

Enfin, parlons de l'opérateur de complément à 1. Cet opérateur inverse tous les bits d'un nombre, transformant les 0 en 1 et vice versa. C'est comme offrir à votre nombre binaire un lifting complet !

#include <stdio.h>

int main() {
    unsigned char a = 5;  // Binaire : 00000101
    unsigned char b = ~a; // Binaire : 11111010

    printf("Valeur originale : %d\n", a);
    printf("Valeur de complément : %d\n", b);

    printf("Représentation binaire :\n");
    printf("a: ");
    for (int i = 7; i >= 0; i--) {
        printf("%d", (a >> i) & 1);
    }
    printf("\nb: ");
    for (int i = 7; i >= 0; i--) {
        printf("%d", (b >> i) & 1);
    }
    printf("\n");

    return 0;
}

Sortie :

Valeur originale : 5
Valeur de complément : 250
Représentation binaire :
a: 00000101
b: 11111010

Dans cet exemple, nous pouvons voir comment l'opérateur de complément à 1 inverse chaque bit. C'est comme tourner votre nombre binaire à l'intérieur du sens !

Et voilà, les amis ! Nous avons exploré tous les opérateurs unaires en C. Souvenez-vous, la pratique fait l'homme parfait, alors n'hésitez pas à expérimenter avec ces opérateurs dans votre propre code. Bon codage, et que les opérateurs unaires soient avec vous !

Opérateur	Nom	Description
++	Incrémentation	Incrémente la valeur de 1
--	Décrémentation	Décrémente la valeur de 1
+	Unary Plus	Indique une valeur positive (rarement utilisé)
-	Unary Minus	Négate une expression
&	Adresse-de	Retourne l'adresse mémoire d'une variable
*	Déférencement	Accède à la valeur à l'adresse d'un pointeur
!	Logique NOT	Inverse l'état logique de son opérande
~	Bitwise NOT (Complément à 1)	Inverse tous les bits

Credits: Image by storyset