Introduction aux opérateurs unaires en C ++
Les opérateurs unaires séparons ces mots clés et les comprenons séparément. L'opérateur dérive de l'opération de mot-clé qui signifie l'opération d'une tâche dans un calcul mathématique impliquant des valeurs d'entrée pour produire une nouvelle valeur en sortie. L'opération que nous effectuons est indiquée par un symbole appelé opérateur. Maintenant, unaire signifie opérateur agissant sur un opérande. Les opérateurs qui opèrent sur un seul opérande sont appelés opérateurs unaires. La nouvelle valeur est produite chaque fois que les opérateurs agissent sur un seul opérande. Il existe également des opérateurs binaires et ternaires qui peuvent être utilisés pour produire une nouvelle valeur lors de différents types de calculs. Les opérateurs binaires opèrent sur deux opérandes tandis que Ternary opère sur trois opérandes. Voici la liste des opérateurs unaires en c ++ expliquée avec des exemples appropriés avec eux.
Différents opérateurs d'Unary en C ++
Il y a neuf opérateurs unaires disponibles en langage de programmation C ++ comme mentionné ci-dessous:
1. Unary Plus
Un opérateur unaire plus est désigné par le symbole «+» et cet opérateur ne modifie pas la valeur de l'opérande. Il représente toujours la valeur des opérandes.
Syntaxe: +
Code:
#include
using namespace std;
int main()
( int y = + 10;
printf("y = %d \n", y);
return 0;
)
Production:
2. Unary Moins
Un opérateur moins unaire est désigné par le symbole «-» et cet opérateur modifie la valeur de l'opérande et, par conséquent, il rend la valeur donnée négative. Convertissez une valeur positive en valeur négative et une valeur négative en valeur positive. Il représente toujours la valeur des opérandes.
Syntaxe: -
Code:
#include
using namespace std;
int main() (
int y;
float x = 2.34;
y = (int) x;
x = -x;
cout << x;
return 0;
)
Production:
3. Opérateur d'incrémentation
L'opérateur d'incrémentation est désigné par le symbole «++». Les opérateurs d'incrémentation augmentent toujours la valeur de 1. Généralement, deux types d'opérateur post-incrémentation et pré-incrémentation.
Syntaxe: ++
Code:
#include
using namespace std;
int main()
(
int p=10;
int q=20;
printf("The value of p: %d\n", ++p);
printf("The value of q: %d\n", q++);
return 0;
)
Production:
4. Opérateur de décrémentation
L'opérateur de décrémentation est désigné par le symbole "-". L'opérateur de décrémentation diminue toujours la valeur de 1. Généralement, deux types d'opérateur post-décrémentation et pré-décrémentation.
Syntaxe: --
Code:
#include
using namespace std;
int main()
(
int p=10;
int q=20;
printf("The value of p: %d\n", --p);
printf("The value of q: %d\n", q--);
return 0;
)
Production:
5. Adresse de l'opérateur
L'adresse de l'opérateur est indiquée par le symbole «&». Cet opérateur renvoie l'adresse de toute variable. Comme il prend généralement l'adresse de son opérande. L'opérande de l'adresse de l'opérateur peut être une fonction ou une valeur entière qui réside dans un objet.
Syntaxe: &
code:
#include
using namespace std;
int main()
(
int x, p=20;
printf("Value of p: %d\n", x);
printf("Address of p: %X\n", &p);
return 0;
)
Production:
6. Taille de l'opérateur
La taille de l'opérateur est indiquée par le symbole «sizeof ()». La taille de l'opérateur agit comme une fonction. Cet opérateur renvoie toujours la variable et la taille occupée par l'objet. Cet opérateur renvoie également la taille de tous les types de données. Il est également connu comme un opérateur unaire au moment de la compilation.
Syntaxe: sizeof()
code:
#include
using namespace std;
int main()
(
int p=20;
printf("The size of p : %d\n", sizeof(p));
printf("The size of 20 : %d\n", sizeof(20));
printf("The size of int : %d\n", sizeof(int));
printf("The size of char : %d\n", sizeof(char));
printf("The size of float: %d\n", sizeof(float));
return 0;
)
Production:
7. Opérateur de déréférencement
L'opérateur de déréférencement est désigné par le symbole «*». Cet opérateur renvoie une valeur entière qui est égale à la valeur d'adresse du pointeur. Cet opérateur est également appelé opérateur d'indirection.
SYNTAXE: *
code:
#include
using namespace std;
int main() (
int x = 5;
int *yx = &x;
int **yyx = &yx;
cout << "Value of x:\n"
<< "the direct value: " << x << endl
<< "the indirect value: " << *yx << endl
<< "the doubly indirect value: " << **yyx << endl
<< "the address of x: " << yx << endl
<< "the address of x via indirection: " << *yyx << endl;
)
Production:
8. NON logique
L'opérateur logique NON est désigné par le symbole «!». Cet opérateur inverse le sens de son opérande. Cet opérateur est également appelé opérateur de négation logique. Implicitement, l'opérande sera converti en un type de données booléen.
Syntaxe:!
code:
#include
using namespace std;
int main() (
int x = 0;
if (!x)
cout << "x is zero" << endl;
)
Production:
9. Bitwise NOT / One's Compliment
L'opérateur NOT au niveau du bit est désigné par le symbole «~». Cet opérateur fournit le complément au niveau du bit de l'opérande. Cet opérateur est également connu sous le nom d'Opérateur Complémentaire. Cela signifie que chaque 1 sera converti en 0 en conséquence.
Syntaxe : ~
code:
#include
using namespace std;
int main () (
unsigned short x = 0xFFFF;
cout << std::hex << x << endl;
x = ~x;
cout << std::hex << x << endl;
)
Production:
Prenons un autre exemple pour représenter les fonctionnalités des opérateurs unaires via un code C ++ unique:
#include
using namespace std;
int main()
(
int x = 1;
cout << "x value: " << x << endl;
int y = x++; // post increment
cout << "y value after x++ : " << y << endl;
cout << "x value after x++ : " << x << endl;
x = 5;
cout << "x value: "<< x< y = --x;
cout << "y value after --x : " << y << endl;
cout << "x value after --x : " << x << endl;
return 0;
)#include
using namespace std;
int main()
(
int x = 1;
cout << "x value: " << x << endl;
int y = x++; // post increment
cout << "y value after x++ : " << y << endl;
cout << "x value after x++ : " << x << endl;
x = 5;
cout << "x value: "<< x< y = --x;
cout << "y value after --x : " << y << endl;
cout << "x value after --x : " << x << endl;
return 0;
)
Production:
Conclusion - Opérateurs unaires en C ++
L'opérateur unaire est très utile pour effectuer divers calculs et convertir des types dans les plus brefs délais. L'efficacité du code peut être augmentée en utilisant ces opérateurs unaires, car vous n'avez pas besoin de créer une fonction pour les tâches de base qui peuvent être effectuées par les opérateurs en un peu de temps.
Articles recommandés
Cela a été un guide pour les opérateurs unaires en C ++. Ici, nous discutons également de leur introduction et des 9 meilleurs opérateurs unaires en c ++. Vous pouvez également consulter les articles suivants pour en savoir plus–
- Opérateurs PowerShell
- Opérateurs Python
- Opérateurs C
- Opérateurs Windows