Opérateurs C++

Dans ce tutoriel, nous allons découvrir les différents types d'opérateurs en C++ à l'aide d'exemples. En programmation, un opérateur est un symbole qui agit sur une valeur ou une variable.

Les opérateurs sont des symboles qui effectuent des opérations sur des variables et des valeurs. Par exemple, + est un opérateur utilisé pour l'addition, tandis que - est un opérateur utilisé pour la soustraction.

Les opérateurs en C++ peuvent être classés en 6 types :

Opérateurs arithmétiques
Opérateurs d'affectation
Opérateurs relationnels
Opérateurs logiques
Opérateurs au niveau du bit
Autres opérateurs

1. Opérateurs arithmétiques C++

Les opérateurs arithmétiques sont utilisés pour effectuer des opérations arithmétiques sur des variables et des données. Par exemple,

a + b;

Ici, le + l'opérateur est utilisé pour additionner deux variables a et b . De même, il existe divers autres opérateurs arithmétiques en C++.

Opérateur	Opération
`+`	Ajout
`-`	Soustraction
`*`	Multiplication
`/`	Division
`%`	Opération modulo (reste après division)

Exemple 1 :Opérateurs arithmétiques

#include <iostream>
using namespace std;

int main() {
    int a, b;
    a = 7;
    b = 2;

    // printing the sum of a and b
    cout << "a + b = " << (a + b) << endl;

    // printing the difference of a and b
    cout << "a - b = " << (a - b) << endl;

    // printing the product of a and b
    cout << "a * b = " << (a * b) << endl;

    // printing the division of a by b
    cout << "a / b = " << (a / b) << endl;

    // printing the modulo of a by b
    cout << "a % b = " << (a % b) << endl;

    return 0;
}

Sortie

a + b = 9
a - b = 5
a * b = 14
a / b = 3
a % b = 1

Ici, les opérateurs + , - et * calculez respectivement l'addition, la soustraction et la multiplication comme on aurait pu s'y attendre.

/ Opérateur de division

Notez l'opération (a / b) dans notre programme. Le / l'opérateur est l'opérateur de division.

Comme nous pouvons le voir dans l'exemple ci-dessus, si un entier est divisé par un autre entier, nous obtiendrons le quotient. Cependant, si le diviseur ou le dividende est un nombre à virgule flottante, nous obtiendrons le résultat en décimales.

In C++,

7/2 is 3
7.0 / 2 is 3.5
7 / 2.0 is 3.5
7.0 / 2.0 is 3.5

Opérateur % modulo

L'opérateur modulo % calcule le reste. Quand a = 9 est divisé par b = 4 , le reste est 1 .

Remarque : Le % L'opérateur ne peut être utilisé qu'avec des nombres entiers.

Opérateurs d'incrémentation et de décrémentation

C++ fournit également des opérateurs d'incrémentation et de décrémentation :++ et -- respectivement.

++ augmente la valeur de l'opérande de 1
-- le diminue de 1

Par exemple,

int num = 5;

// increment operator
++num;  // 6

Ici, le code ++num; augmente la valeur de num par 1 .

Exemple 2 : Opérateurs d'incrémentation et de décrémentation

// Working of increment and decrement operators

#include <iostream>
using namespace std;

int main() {
    int a = 10, b = 100, result_a, result_b;

    // incrementing a by 1 and storing the result in result_a
    result_a = ++a;
    cout << "result_a = " << result_a << endl;


    // decrementing b by 1 and storing the result in result_b   
    result_b = --b;
    cout << "result_b = " << result_b << endl;

    return 0;
}

Sortie

result_a = 11
result_b = 99

Dans le programme ci-dessus, nous avons utilisé le ++ et -- opérateurs sous forme de préfixes (++a et --b) . Cependant, nous pouvons également utiliser ces opérateurs comme suffixe (a++ et b--) .

Pour en savoir plus, consultez les opérateurs d'incrémentation et de décrémentation.

2. Opérateurs d'affectation C++

En C++, les opérateurs d'affectation sont utilisés pour affecter des valeurs aux variables. Par exemple,

// assign 5 to a
a = 5;

Ici, nous avons attribué une valeur de 5 à la variable a .

Opérateur	Exemple	Équivalent à
`=`	`a = b;`	`a = b;`
`+=`	`a += b;`	`a = a + b;`
`-=`	`a -= b;`	`a = a - b;`
`*=`	`a *= b;`	`a = a * b;`
`/=`	`a /= b;`	`a = a / b;`
`%=`	`a %= b;`	`a = a % b;`

Exemple 3 :Opérateurs d'affectation

#include <iostream>
using namespace std;

int main() {
    int a, b;

    // 2 is assigned to a
    a = 2;

    // 7 is assigned to b
    b = 7;

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "\nAfter a += b;" << endl;

    // assigning the sum of a and b to a
    a += b;  // a = a +b
    cout << "a = " << a << endl;

    return 0;
}

Sortie

a = 2
b = 7

After a += b;
a = 9

3. Opérateurs relationnels C++

Un opérateur relationnel est utilisé pour vérifier la relation entre deux opérandes. Par exemple,

// checks if a is greater than b
a > b;

Ici, > est un opérateur relationnel. Il vérifie si a est supérieur à b ou pas.

Si la relation est vraie , il renvoie 1 alors que si la relation est fausse , il renvoie 0 .

Opérateur	Signification	Exemple
`==`	Est égal à	`3 == 5` nous donne faux
`!=`	Pas égal à	`3 != 5` nous donne vrai
`>`	Supérieur à	`3 > 5` nous donne faux
`<`	Moins de	`3 < 5` nous donne vrai
`>=`	Supérieur ou égal à	`3 >= 5` donnez-nous faux
`<=`	Inférieur ou égal à	`3 <= 5` nous donne vrai

Exemple 4 :Opérateurs relationnels

#include <iostream>
using namespace std;

int main() {
    int a, b;
    a = 3;
    b = 5;
    bool result;

    result = (a == b);   // false
    cout << "3 == 5 is " << result << endl;

    result = (a != b);  // true
    cout << "3 != 5 is " << result << endl;

    result = a > b;   // false
    cout << "3 > 5 is " << result << endl;

    result = a < b;   // true
    cout << "3 < 5 is " << result << endl;

    result = a >= b;  // false
    cout << "3 >= 5 is " << result << endl;

    result = a <= b;  // true
    cout << "3 <= 5 is " << result << endl;

    return 0;
}

Sortie

3 == 5 is 0
3 != 5 is 1
3 > 5 is 0
3 < 5 is 1
3 >= 5 is 0
3 <= 5 is 1

Remarque :Les opérateurs relationnels sont utilisés dans la prise de décision et les boucles.

4. Opérateurs logiques C++

Les opérateurs logiques sont utilisés pour vérifier si une expression est vraie ou faux . Si l'expression est vraie , il renvoie 1 alors que si l'expression est fausse , il renvoie 0 .

Opérateur	Exemple	Signification
`&&`	expression1 && expression2	ET logique. Vrai uniquement si tous les opérandes sont vrais.
`\|\|`	expression1 \|\| expression2	OU logique. Vrai si au moins un des opérandes est vrai.
`!`	! expression	NON logique. Vrai uniquement si l'opérande est faux.

En C++, les opérateurs logiques sont couramment utilisés dans la prise de décision. Pour mieux comprendre les opérateurs logiques, voyons les exemples suivants,

Suppose,
a = 5
b = 8

Then,

(a > 3) && (b > 5) evaluates to true
(a > 3)  && (b < 5) evaluates to false

(a > 3) || (b > 5) evaluates to true
(a > 3) || (b < 5) evaluates to true
(a < 3) || (b < 5) evaluates to false

!(a < 3) evaluates to true
!(a > 3) evaluates to false

Exemple 5 :Opérateurs logiques

#include <iostream>
using namespace std;

int main() {
    bool result;

    result = (3 != 5) && (3 < 5);     // true
    cout << "(3 != 5) && (3 < 5) is " << result << endl;

    result = (3 == 5) && (3 < 5);    // false
    cout << "(3 == 5) && (3 < 5) is " << result << endl;

    result = (3 == 5) && (3 > 5);    // false
    cout << "(3 == 5) && (3 > 5) is " << result << endl;

    result = (3 != 5) || (3 < 5);    // true
    cout << "(3 != 5) || (3 < 5) is " << result << endl;

    result = (3 != 5) || (3 > 5);    // true
    cout << "(3 != 5) || (3 > 5) is " << result << endl;

    result = (3 == 5) || (3 > 5);    // false
    cout << "(3 == 5) || (3 > 5) is " << result << endl;

    result = !(5 == 2);    // true
    cout << "!(5 == 2) is " << result << endl;

    result = !(5 == 5);    // false
    cout << "!(5 == 5) is " << result << endl;

    return 0;
}

Sortie

(3 != 5) && (3 < 5) is 1
(3 == 5) && (3 < 5) is 0
(3 == 5) && (3 > 5) is 0
(3 != 5) || (3 < 5) is 1
(3 != 5) || (3 > 5) is 1
(3 == 5) || (3 > 5) is 0
!(5 == 2) is 1
!(5 == 5) is 0

Explication du programme d'opérateur logique

(3 != 5) && (3 < 5) évalue à 1 car les deux opérandes (3 != 5) et (3 < 5) sont 1 (vrai).
(3 == 5) && (3 < 5) est évalué à 0 car l'opérande (3 == 5) est 0 (faux).
(3 == 5) && (3 > 5) est évalué à 0 car les deux opérandes (3 == 5) et (3 > 5) sont 0 (faux).
(3 != 5) || (3 < 5) évalue à 1 car les deux opérandes (3 != 5) et (3 < 5) sont 1 (vrai).
(3 != 5) || (3 > 5) évalue à 1 car l'opérande (3 != 5) est 1 (vrai).
(3 == 5) || (3 > 5) est évalué à 0 car les deux opérandes (3 == 5) et (3 > 5) sont 0 (faux).
!(5 == 2) évalue à 1 car l'opérande (5 == 2) est 0 (faux).
!(5 == 5) est évalué à 0 car l'opérande (5 == 5) est 1 (vrai).

5. Opérateurs binaires C++

En C++, les opérateurs au niveau du bit sont utilisés pour effectuer des opérations sur des bits individuels. Ils ne peuvent être utilisés qu'avec char et int types de données.

Opérateur	Description
`&`	ET binaire
`\|`	OU binaire
`^`	XOR binaire
`~`	Complément binaire à un
`<<`	Décalage binaire vers la gauche
`>>`	Décalage binaire vers la droite

Pour en savoir plus, consultez Opérateurs bit à bit C++.

6. Autres opérateurs C++

Voici une liste de quelques autres opérateurs courants disponibles en C++. Nous en apprendrons plus sur eux dans des tutoriels ultérieurs.

Opérateur	Description	Exemple
`sizeof`	renvoie la taille du type de données	`sizeof(int); // 4`
`?:`	renvoie la valeur en fonction de la condition	`string result = (5 > 0) ? "even" : "odd"; // "even"`
`&`	représente l'adresse mémoire de l'opérande	`&num; // address of num`
`.`	accède aux membres des variables struct ou des objets de classe	`s1.marks = 92;`
`->`	utilisé avec des pointeurs pour accéder aux variables de classe ou de structure	`ptr->marks = 92;`
`<<`	imprime la valeur de sortie	`cout << 5;`
`>>`	obtient la valeur d'entrée	`cin >> num;`

Conversion de types C++ Commentaires C++

Langue C