C++ prend en charge plusieurs opérateurs unaires, chacun remplissant un objectif unique dans la manipulation des variables. Commençons par les opérateurs d’incrémentation et de décrémentation qui sont couramment utilisés dans les boucles et divers algorithmes.
Exemple 1 : opérateurs d'incrémentation (++) et de décrémentation (–)
Les opérateurs unaires d'incrémentation (++) et de décrémentation (–) sont des outils fondamentaux en C++ pour modifier la valeur d'une variable en l'augmentant ou en la diminuant de 1, respectivement. L'opérateur d'incrémentation (++) ajoute 1 à la valeur de la variable, tandis que l'opérateur de décrémentation (–) soustrait 1. Ces opérateurs peuvent être appliqués aux variables entières, à virgule flottante et à pointeur, offrant une flexibilité dans leur utilisation.
Explorons ces opérateurs à travers un exemple pratique :
#include
en utilisant espace de noms norme ;
int principal ( )
{
int comptoir = 0 ;
// Opérateur d'incrémentation
cout << 'Valeur initiale: ' << comptoir << fin ;
comptoir ++ ;
cout << 'Valeur après incrément : ' << comptoir << fin ;
// Opérateur de décrémentation
comptoir -- ;
cout << 'Valeur après décrémentation : ' << comptoir << fin ;
retour 0 ;
}
Ce simple programme C++ inclut la bibliothèque de flux d'entrée/sortie nécessaire avec « #include
Après cette opération, la valeur mise à jour de « counter » est affichée à l'aide d'une autre instruction « cout ». Par la suite, nous utilisons l'opérateur de décrémentation (counter—) pour diminuer la valeur de « counter » de 1. Le résultat est ensuite affiché sur la console. En fin de compte, le programme se termine par le « retour 0 ; » instruction qui indique une exécution réussie.
L'image de sortie affiche la valeur initiale, la valeur après l'incrément et la valeur décrémentée.
Exemple 2 : Opérateurs positifs (+) et négatifs (-)
Si l’opérateur unaire positif est rarement utilisé, l’opérateur négatif est fondamental pour changer le signe d’une variable.
#includeEn utilisant espace de noms norme ;
int principal ( ) {
int valeur positive = dix ;
int valeur négative = - valeur positive ;
cout << « Valeur positive : » << valeur positive << fin ;
cout << 'Valeur négative: ' << valeur négative << fin ;
retour 0 ;
}
Nous initialisons deux variables entières pour cet exemple de code qui sont « positiveValue » et « negativeValue ». La « positiveValue » reçoit la valeur 10. Par la suite, nous déclarons la « negativeValue » et lui attribuons la négation de « positiveValue » à l’aide de l’opérateur unaire moins. Cet opérateur change effectivement le signe de la valeur d'origine. Nous utilisons ensuite l'instruction « cout » pour afficher à la fois la sortie positive et la sortie négative sur la console. Enfin, le programme renvoie 0, ce qui indique la réussite de la fonction principale.
Une fois exécuté, ce programme génère les valeurs positives et négatives.
Exemple 3 : Opérateur logique NOT (!)
L'opérateur unaire en C++, désigné par le « ! » symbole, est connu sous le nom d’opérateur logique NOT. Il est conçu pour inverser la valeur de vérité d’une expression donnée. Il opère sur un seul opérande qui est généralement une expression logique ou une condition. L'opération logique NON donne un résultat « vrai » lorsque l'opérande est « faux » et donne un résultat « faux » lorsque l'opérande est « vrai ».
Voici un exemple simple qui démontre l’utilisation de l’opérateur logique NOT :
#includeen utilisant espace de noms norme ;
int principal ( ) {
bouffon est vrai = vrai ;
bouffon c'est faux = FAUX ;
bouffon résultatNotTrue = ! est vrai ;
bouffon résultatNotFalse = ! c'est faux ;
cout << 'Valeur d'origine: ' << est vrai << ', Après NON : ' << résultatNotTrue << fin ;
cout << 'Valeur d'origine: ' << c'est faux << ', Après NON : ' << résultatNotFalse << fin ;
retour 0 ;
}
Dans cet exemple, nous déclarons deux variables booléennes, « isTrue » et « isFalse ». Nous appliquons ensuite l'opérateur logique NOT à chaque variable, en stockant les résultats respectivement dans « resultNotTrue » et « resultNotFalse ». Le programme imprime ensuite les valeurs d'origine et les résultats de l'opération logique NON pour les deux variables.
Lors de l'exécution de ce programme, nous remarquerons que l'opérateur logique NOT inverse la valeur de vérité de « isTrue » (initialement définie sur true), la rendant fausse. De même, il inverse la valeur de vérité de « isFalse » (à l’origine faux), donnant vrai.
Le résultat illustre clairement l’inversion des valeurs de vérité obtenues par l’opérateur logique NOT.
Exemple 4 : opérateur NOT (~) au niveau du bit
L'opérateur NOT au niveau du bit (~) en C++ est un opérateur unaire qui effectue la négation au niveau du bit de chaque bit de son opérande. Il fonctionne avec des types de données fondamentaux, en particulier ceux intégraux, tels que les entiers. Le résultat est obtenu en inversant chaque bit individuel de l’opérande, en convertissant les 0 en 1 et les 1 en 0.
Pour illustrer son utilisation, considérons l'extrait de code suivant :
#includeen utilisant espace de noms norme ;
int principal ( ) {
int valeur d'origine = 5 ;
int resultBitwiseNot = ~valeuroriginale ;
cout << 'Valeur d'origine: ' << valeur d'origine << ', Après Bitwise NOT : ' << resultBitwiseNot << fin ;
retour 0 ;
}
Dans cet exemple, nous déclarons une variable entière « originalValue » avec la valeur « 5 ». Ensuite, nous utilisons l'opérateur NOT au niveau du bit (~) sur cette variable. Le résultat de cette variable est stocké dans « resultBitwiseNot ». Le programme imprime ensuite la valeur d'origine et le résultat après l'opération NOT au niveau du bit en utilisant l'instruction « cout ».
Lorsque nous exécuterons ce programme, nous verrons que l'opérateur NOT au niveau du bit inverse chaque bit de la représentation binaire de « originalValue », ce qui donne une nouvelle valeur.
Exemple 5 : Opérateurs d'adresse et d'indirection
L'opérateur d'adresse de, désigné par le symbole « & », sert à récupérer l'emplacement mémoire d'une variable. Il renvoie un pointeur sur la variable qui permet un accès indirect à sa valeur. L'opérateur d'indirection ou de déréférencement (*) obtient la valeur stockée à l'emplacement mémoire spécifié par un pointeur. Il fournit un moyen de travailler indirectement avec les données réelles via un pointeur.
Comprenons le concept avec un exemple :
#includeen utilisant espace de noms norme ;
int principal ( ) {
int valeur = 99 ;
cout << 'Valeur d'origine: ' << valeur << fin ;
int * ptr = & valeur ;
cout << « Adresse mémoire : » << ptr << fin ;
int valeur récupérée = * ptr ;
cout << « Valeur récupérée : » << valeur récupérée << fin ;
retour 0 ;
}
Ce code illustre l'utilisation des opérateurs d'adresse et d'indirection. Tout d’abord, une variable entière nommée « valeur » est initialisée avec la valeur 99. La valeur originale de « valeur » est ensuite sortie sur la console. Par la suite, une variable de pointeur « ptr » est déclarée et l'opérateur d'adresse de (&) est utilisé pour attribuer l'adresse mémoire de « valeur » à « ptr ». Le programme génère ensuite cette adresse mémoire, présentant le fonctionnement de base de l'opérateur « adresse ».
Après cela, une nouvelle variable entière « retrievedValue » est déclarée et l'opérateur d'indirection (*) est utilisé pour récupérer la valeur stockée à l'adresse mémoire pointée par « ptr ». La valeur récupérée est ensuite affichée sur la console.
Conclusion
Cet article a fourni une exploration complète des opérateurs unaires en C++. Nous avons commencé par classer les opérateurs unaires en différents types, notamment arithmétiques, logiques, au niveau du bit et ceux liés à l'adresse et à l'indirection. Des situations du monde réel ont été illustrées pour démontrer l’application utile de ces opérateurs. Ces opérateurs jouent un rôle central dans la programmation C++, ce qui permet aux développeurs de travailler efficacement avec des pointeurs et de gérer la mémoire.