C++ opérateur

Dans ce tutoriel, nous allons apprendre C ++Différents types d'opérateurs. Dans la programmation, un opérateur est un symbole utilisé pour effectuer des opérations sur des valeurs ou des variables.

Un opérateur est un symbole utilisé pour effectuer des opérations sur des variables et des valeurs. Par exemple,+C'est l'opérateur utilisé pour l'addition, et - C'est l'opérateur utilisé pour la soustraction.

C ++中的运算符可以分为六种类型：

1. 其他运算符

2. opérateur d'affectation

3. Opérateurs de comparaison

4. Opérateurs logiques

5. opérateurs de bit

6. 中的运算符可以分为六种类型：

1. C ++其他运算符

算术运算符

a　+　b;

Les opérateurs arithmétiques sont utilisés pour effectuer des opérations arithmétiques sur les variables et les données. Par exemple,+Dans ce cas, ++运算符用于将两个变量a和b相加。同样，C

Supposons que la valeur de la variable A soit 10，la valeur de la variable B est 2Dans, il y a d'autres opérateurs arithmétiques variés.

Exemple1A

#include <iostream>
using namespace std;
int main() {
　　　　int a, b;
　　　　a =　7;
　　　　b =　2;
　　　　//　：算术运算符
　　　　Imprimer a divisé par b　+　cout << "a　+　b) << endl;
　　　　//　Imprimer la somme de a et b
　　　　Imprimer a divisé par b　-　cout << "a　-　b) << endl;
　　　　//　Imprimer la différence entre a et b
　　　　Imprimer a divisé par b　*　cout << "a　*　b) << endl;
　　　　//　Imprimer le produit de a et b
　　　　Imprimer a divisé par b　/　cout << "a　/　b) << endl;
　　　　//　Imprimer le reste de a et b
　　　　cout << "a % b = " << (a % b) << endl;
　　　　return 0;
}

Résultat de la sortie

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

Ici, l'opérateur+,- et * calcule respectivement l'addition, la soustraction et la multiplication, comme on s'y attend.

/ opérateur de division

Attention aux opérations dans notre programme (a / b). 　/ L'opérateur est l'opérateur de division.

Comme on peut le voir dans les exemples ci-dessus, si un entier est divisé par un autre entier, on obtient un quotient. Cependant, si le diviseur ou le dividend est un nombre à virgule flottante, on obtient un résultat sous forme de nombre décimal.

Dans C++Dans,
7/2　=　3
7.0　/　2　=　3.5
7　/　2.0 =　3.5
7.0　/　2.0 =　3.5

opérateur % modulo

L'opérateur modulo % calcule le reste. Lorsque a (9) divisé par b(4) le reste est1.

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

opérateurs d'auto-incrémentation et d'auto-décrémentation

C ++Des opérateurs d'incrémentation et de décrémentation sont également fournis :++et--.

++Augmenter la valeur de l'opérande1.

-- Réduire la valeur de l'opérande1.

Par exemple,

int num =　5;
//　num augmente1
++num;

Ici, la valeur de num à partir de la valeur initiale5augmenter6.

Exemple2: opérateurs d'incrémentation et de décrémentation

//　Le fonctionnement des opérateurs d'incrémentation et de décrémentation
#include <iostream>
using namespace std;
int main() {
　　　　int a =　10, b =　10, 0, result_a, result_b;
　　　　//　Ajouter a1et stocker le résultat dans result_a
　　　　result_a =　++a;
　　　　cout << "result_a = " << result_a << endl;
　　　　//　Soustraire b1et stocker le résultat dans result_b
　　　　result_b =　--b;
　　　　cout << "result_b = " << result_b << endl;
　　　　return 0;
}

Résultat de la sortie

result_a =　11
result_b =　99

Dans le programme ci-dessus, nous utilisons++et-opérateurs utilisés comme préfixe. Nous pouvons également utiliser ces opérateurs comme suffixe.

Ces opérateurs diffèrent légèrement lorsqu'ils sont utilisés comme préfixe ou suffixe.

2. C ++ opérateur d'affectation

Dans C ++En chinois simplifié, l'opérateur d'affectation est utilisé pour attribuer une valeur à une variable. Par exemple,

//　}}5Affectation à a
a =　5;

Ici, nous avons affecté une valeur à la variable a5.

Exemple2：Opérateurs d'affectation

#include <iostream>
using namespace std;
int main() {
　　　　int a, b, temp;
　　　　//　a affectation2
　　　　a =　2;
　　　　//b affectation7
　　　　b =　7;
　　　//　Affectez la valeur de a à temp
　　　temp = a;　　　　//　temp sera　2
　　　cout << "temp = " << temp << endl;
　　　　//　Assignez la somme de a et b à a
　　　　a　+= b;　　　　　　　//　a = a　+b
　　　　cout << "a = " << a << endl;
　　　　return 0;
}

Résultat de la sortie

temp =　2
a =　9

3. C ++Opérateurs de comparaison

Les opérateurs de comparaison sont utilisés pour vérifier la relation entre deux opérandes. Par exemple,

//　Vérifiez si a est supérieur à b
a > b;

Ici, > est un opérateur de comparaison. Il vérifie si a est supérieur à b.

Si cette relation esttrue，alors retourne1;Si cette relation estfalse，alors retourne0.

Supposons que la valeur de la variable A soit 5，la valeur de la variable B est 11, alors :

Exemple4：Opérateurs de comparaison

#include <iostream>
using namespace std;
int main() {
　　　　int a, b;
　　　　a =　3;
　　　　b =　5;
　　　　bool result;
　　　　result = (a == b);　　　//　false
　　　　cout << "3　==　5　Le résultat du calcul est " << result << endl;
　　　　result = (a != b);　　//　true
　　　　cout << "3　!=　5　Le résultat du calcul est " << result << endl;
　　　　result = a > b;　　　//　false
　　　　cout << "3　>　5　Le résultat du calcul est " << result << endl;
　　　　result = a < b;　　　//　true
　　　　cout << "3　<　5　Le résultat du calcul est " << result << endl;
　　　　result = a >= b;　　//　false
　　　　cout << "3　>=　5　Le résultat du calcul est " << result << endl;
　　　　result = a <= b;　　//　true
　　　　cout << "3　<=　5　Le résultat du calcul est " << result << endl;
　　　　return 0;
}

Résultat de la sortie

3　==　5　Le résultat du calcul est 0
3　!=　5　Le résultat du calcul est　1
3　>　5　Le résultat du calcul est 0
3　<　5　Le résultat du calcul est　1
3　>=　5　Le résultat du calcul est 0
3　<=　5　Le résultat du calcul est　1

Attention：Les opérateurs de comparaison sont utilisés pour la décision et les boucles.

4. C ++Opérateurs logiques

Les opérateurs logiques sont utilisés pour vérifier si une expression esttrueoufalse。Si l'expression esttrue，alors retourne1;Si l'expression estfalse，alors retourne0.

p> Supposons que la valeur de la variable A soit 1，si la valeur de la variable B est 0, alors :

Dans C ++dans lequel les opérateurs logiques sont généralement utilisés pour la prise de décision. Pour mieux comprendre les opérateurs logiques, regardons les exemples suivants,

Supposons que,
a =　5
b =　8
Si,
(a >　3) && (b >　5) resultat de calcul true
(a >　3) && (b <　5) resultat de calcul false
(a >　3) || (b >　5) resultat de calcul true
(a >　3) || (b <　5) resultat de calcul true
(a <　3) || (b <　5) resultat de calcul false
!(a ==　3) resultat de calcul true
!(a >　3) resultat de calcul false

Exemple5：opérateurs logiques

#include <iostream>
using namespace std;
int main() {
　　　　bool result;
　　　　result = (3　!=　5) && (3　<　5;　　　　　//　true
　　　　cout << "(3　!=　5) && (3　<　5) resultat de calcul 0 " << result << endl;
　　　　result = (3　==　5) && (3　<　5;　　　　//　false
　　　　cout << "(3　==　5) && (3　<　5) resultat de calcul 0 " << result << endl;
　　　　result = (3　==　5) && (3　>　5;　　　　//　false
　　　　cout << "(3　==　5) && (3　>　5) resultat de calcul 0 " << result << endl;
　　　　result = (3　!=　5) || (3　<　5;　　　　//　true
　　　　cout << "(3　!=　5) || (3　<　5) resultat de calcul 0 " << result << endl;
　　　　result = (3　!=　5) || (3　>　5;　　　　//　true
　　　　cout << "(3　!=　5) || (3　>　5) resultat de calcul 0 " << result << endl;
　　　　result = (3　==　5) || (3　>　5;　　　　//　false
　　　　cout << "(3　==　5) || (3　>　5) resultat de calcul 0 " << result << endl;
　　　　result = !(5　==　2;　　　　//　true
　　　　cout << "!(5　==　2) resultat de calcul 0 " << result << endl;
　　　　result = !(5　==　5;　　　　//　false
　　　　cout << "!(5　==　5) resultat de calcul 0 " << result << endl;
　　　　return 0;
}

Résultat de la sortie

(3　!=　5) && (3　<　5) resultat de calcul　1
(3　==　5) && (3　<　5) resultat de calcul 0
(3　==　5) && (3　>　5) resultat de calcul 0
(3　!=　5) || (3　<　5) resultat de calcul　1
(3　!=　5) || (3　>　5) resultat de calcul　1
(3　==　5) || (3　<　5) resultat de calcul 0
!(5　==　2) resultat de calcul　1
!(5　==　5) resultat de calcul 0

L'utilisation des opérateurs logiques dans les programmes logiques

• (3!= 5) && (3 <5) évalue à1, car les deux opérandes(3!= 5) et (3 <5) sont1(true).

• (3 == 5) && (3 <5) évalue à 0, car l'opérande(3 == 5) évalue à 0(false).

• (3 == 5) && (3> 5) évaluent à 0, car les deux opérandes(3 == 5) et (3> 5) sont tous à 0(false).

• (3!= 5) || (3 <5) évalue à1, car les deux opérandes(3!= 5) et (3 <5) sont1(true).

• (3!= 5) || (3> 5) évalue à1, car l'opérande(3!= 5) est1(true).

• (3 == 5) || (3> 5) évaluent à 0, car les deux opérandes(3 == 5) et (3> 5) sont tous à 0(false).

• !(5 == 2) évalue à1, car l'opérande(5 == 2) évalue à 0(false).

• !(5 == 5) évalue à 0, car l'opérande(5 == 5) est1(true).

5. C ++opérateurs de bit

Dans C ++dans lequel les opérateurs de bit sont utilisés pour exécuter des opérations sur des bits individuels. Ils ne peuvent être utilisés qu'avec les types de données char et int.

Le tableau suivant montre C++ Opérateurs de bit pris en charge. Supposons que la valeur de la variable A soit 60, la valeur de la variable B est 13, alors :

Pour plus d'informations, veuillez visiterC ++opérateurs de bit.

En plus des opérateurs discutés précédemment, il y a aussi d'autres opérateurs, tels que sizeof, ?, ., &, etc., qui ne peuvent pas être classés dans une ou l'autre catégorie. Nous apprendrons plus à propos de ces opérateurs dans les prochaines leçons.

opérateurs divers

Le tableau suivant liste les opérateurs C++ d'autres opérateurs importants pris en charge.

C++ de l'opérateur dans

La priorité des opérateurs détermine la combinaison des éléments dans l'expression. Cela affecte la manière dont une expression est calculée. Certains opérateurs ont une priorité plus élevée que d'autres, par exemple, les opérateurs de multiplication et de division ont une priorité plus élevée que les opérateurs d'addition et de soustraction.

par exemple x = 7 + 3 * 2ici, x est affecté à 13, pas 20, car l'opérateur * plus + une priorité plus élevée, donc la multiplication est calculée en premier 3*2ensuite, en plus de 7.

Le tableau suivant liste les opérateurs par priorité décroissante des opérateurs, les opérateurs de priorité élevée apparaissent en haut du tableau, et les opérateurs de priorité faible apparaissent en bas du tableau. Dans l'expression, les opérateurs de priorité élevée sont calculés en premier.

Exemple : priorité des opérateurs

#include <iostream>
using namespace std;
int main() {
　　//　résoudre d'abord17　*　6
　　int num1　=　5　-　17　*　6;
　　//　et num1expression équivalente
　　int num2　=　5　-　(17　*　6;
　　//　force le compilateur à résoudre d'abord5　-　17valeur
　　int num3　=5　-　17)　*　6;
　　cout << "num1　=1　<< endl;
　　cout << "num2　=2　<< endl;
　　cout << "num3　=3　<< endl;
　　return 0;
}

num1　=　-97
num2　=　-97
num3　=　-72