Opérateurs en C++ : Votre Porte d'Entrée vers la Magie de la Programmation
Bonjour là-bas, futurs magiciens de la programmation ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde des opérateurs C++. Ne vous inquiétez pas si vous n'avez jamais écrit une ligne de code auparavant - je suis là pour vous guider à chaque étape, comme j'ai fait pour des centaines d'étudiants au fil des ans. Alors, prenez votre baguette virtuelle (clavier), et lançons quelques sorts de programmation !
Qu'est-ce que les Opérateurs ?
Avant de plonger dedans, comprenons ce qu'est un opérateur. En C++, les opérateurs sont des symboles spéciaux qui indiquent à l'ordinateur d'effectuer des manipulations mathématiques ou logiques spécifiques. Pensez à eux comme les mots magiques dans votre grimoire - chacun fait quelque chose de unique !
Opérateurs Arithmétiques
Commençons par les bases - les opérateurs arithmétiques. Ceux-ci vous sont probablement familiers de vos cours de mathématiques, mais maintenant nous allons les utiliser pour faire des calculs avec notre ordinateur !
Voici un tableau des opérateurs arithmétiques en C++ :
| Opérateur | Description | Exemple |
|---|---|---|
| + | Addition | a + b |
| - | Soustraction | a - b |
| * | Multiplication | a * b |
| / | Division | a / b |
| % | Modulo (reste) | a % b |
| ++ | Incrément | a++ ou ++a |
| -- | Décrément | a-- ou --a |
Voyons-les en action :
#include <iostream>
using namespace std;
int main() {
int a = 10, b = 3;
cout << "a + b = " << a + b << endl; // Output: 13
cout << "a - b = " << a - b << endl; // Output: 7
cout << "a * b = " << a * b << endl; // Output: 30
cout << "a / b = " << a / b << endl; // Output: 3
cout << "a % b = " << a % b << endl; // Output: 1
cout << "a++ = " << a++ << endl; // Output: 10
cout << "Now a = " << a << endl; // Output: 11
cout << "++b = " << ++b << endl; // Output: 4
cout << "Now b = " << b << endl; // Output: 4
return 0;
}Dans cet exemple, nous effectuons diverses opérations arithmétiques. Notez que a++ affiche 10 mais que a devient 11 ? C'est parce que a++ est un incrément postfixe - il utilise la valeur, puis l'augmente. D'autre part, ++b est un incrément préfixe - il augmente la valeur avant de l'utiliser.
Opérateurs de Comparaison
Passons aux opérateurs de comparaison. Ceux-ci sont utilisés pour comparer des valeurs et renvoient soit true (1) soit false (0). Ils sont comme les juges dans un duel magique !
Voici un tableau des opérateurs de comparaison :
| Opérateur | Description | Exemple |
|---|---|---|
| == | Égal à | a == b |
| != | Différent de | a != b |
| > | Supérieur à | a > b |
| < | Inférieur à | a < b |
| >= | Supérieur ou égal à | a >= b |
| <= | Inférieur ou égal à | a <= b |
Voyons-les en action :
#include <iostream>
using namespace std;
int main() {
int a = 10, b = 5;
cout << "a == b is " << (a == b) << endl; // Output: 0 (false)
cout << "a != b is " << (a != b) << endl; // Output: 1 (true)
cout << "a > b is " << (a > b) << endl; // Output: 1 (true)
cout << "a < b is " << (a < b) << endl; // Output: 0 (false)
cout << "a >= b is " << (a >= b) << endl; // Output: 1 (true)
cout << "a <= b is " << (a <= b) << endl; // Output: 0 (false)
return 0;
}Dans ce sortilège... je veux dire, programme, nous comparons a et b en utilisant différents opérateurs de comparaison. Souvenez-vous, en C++, true est représenté par 1 et false par 0.
Opérateurs Logiques
Maintenant, ajoutons un peu de logique à notre magie ! Les opérateurs logiques sont utilisés pour combiner des déclarations conditionnelles.
Voici un tableau des opérateurs logiques :
| Opérateur | Description | Exemple |
|---|---|---|
| && | ET logique | a && b |
| || | OU logique | a || b |
| ! | NON logique | !a |
Voyons un sort avec ceux-ci :
#include <iostream>
using namespace std;
int main() {
bool a = true, b = false;
cout << "a && b is " << (a && b) << endl; // Output: 0 (false)
cout << "a || b is " << (a || b) << endl; // Output: 1 (true)
cout << "!a is " << (!a) << endl; // Output: 0 (false)
cout << "!b is " << (!b) << endl; // Output: 1 (true)
return 0;
}Dans cette incantation magique, nous utilisons des opérateurs logiques pour combiner ou inverser des valeurs booléennes. && renvoie true uniquement si les deux opérandes sont true, || renvoie true si au moins un opérande est true, et ! inverse la valeur booléenne.
Opérateurs Bitwise
Maintenant, nous entrons dans le royaume de la magie avancée - les opérateurs bitwise. Ceux-ci opèrent sur les bits individuels des valeurs entières. Ils sont comme les micro-sortilèges du monde de la programmation !
Voici un tableau des opérateurs bitwise :
| Opérateur | Description | Exemple |
|---|---|---|
| & | ET bitwise | a & b |
| | | OU bitwise | a | b |
| ^ | XOR bitwise | a ^ b |
| ~ | NON bitwise | ~a |
| << | Décalage à gauche | a << n |
| >> | Décalage à droite | a >> n |
Voyons un peu de magie bit :
#include <iostream>
using namespace std;
int main() {
unsigned int a = 60; // 60 = 0011 1100 en binaire
unsigned int b = 13; // 13 = 0000 1101 en binaire
cout << "a & b = " << (a & b) << endl; // Output: 12 (0000 1100 en binaire)
cout << "a | b = " << (a | b) << endl; // Output: 61 (0011 1101 en binaire)
cout << "a ^ b = " << (a ^ b) << endl; // Output: 49 (0011 0001 en binaire)
cout << "~a = " << (~a) << endl; // Output: -61 (1100 0011 en binaire)
cout << "a << 2 = " << (a << 2) << endl; // Output: 240 (1111 0000 en binaire)
cout << "a >> 2 = " << (a >> 2) << endl; // Output: 15 (0000 1111 en binaire)
return 0;
}Ce sortilège pourrait sembler un peu complexe, mais il effectue des opérations sur les bits individuels de nos nombres. Par exemple, & effectue une opération ET sur chaque paire de bits correspondante, | effectue une opération OU, et ainsi de suite. Les opérations de décalage << et >> déplacent tous les bits à gauche ou à droite par un nombre spécifié de positions.
Opérateurs d'Affectation
Les opérateurs d'affectation sont utilisés pour assigner des valeurs aux variables. Ils sont comme les plumes qui écrivent dans votre grimoire !
Voici un tableau des opérateurs d'affectation :
| Opérateur | Description | Exemple |
|---|---|---|
| = | Affectation simple | a = b |
| += | Ajouter et affecter | a += b |
| -= | Soustraire et affecter | a -= b |
| *= | Multiplier et affecter | a *= b |
| /= | Diviser et affecter | a /= b |
| %= | Modulo et affecter | a %= b |
| <<= | Décalage à gauche et affecter | a <<= b |
| >>= | Décalage à droite et affecter | a >>= b |
| &= | ET bitwise et affecter | a &= b |
| ^= | XOR bitwise et affecter | a ^= b |
| |= | OU bitwise et affecter | a |= b |
Voyons comment écrire des valeurs dans notre grimoire :
#include <iostream>
using namespace std;
int main() {
int a = 10;
cout << "Initial value of a: " << a << endl;
a += 5; // Équivalent à : a = a + 5
cout << "After a += 5: " << a << endl;
a -= 3; // Équivalent à : a = a - 3
cout << "After a -= 3: " << a << endl;
a *= 2; // Équivalent à : a = a * 2
cout << "After a *= 2: " << a << endl;
a /= 4; // Équivalent à : a = a / 4
cout << "After a /= 4: " << a << endl;
a %= 3; // Équivalent à : a = a % 3
cout << "After a %= 3: " << a << endl;
return 0;
}Dans ce script magique, nous utilisons divers opérateurs d'affectation pour modifier la valeur de a. Ces opérateurs combinent l'affectation avec une autre opération, rendant notre code plus concis.
Opérateurs Divers
C++拥有一些其他不属于其他类别的运算符。它们就像我们咒语牌组中的野生牌！
以下是杂项运算符的表格：
| 运算符 | 描述 | 示例 |
|---|---|---|
| sizeof | 返回变量的大小 | sizeof(a) |
| ?: | 三元运算符 | condition ? expr1 : expr2 |
| & | 返回变量的地址 | &a |
| * | 指向变量的指针 | *ptr |
| . | 访问结构变量的成员或类对象 | object.member |
| -> | 通过指针访问结构或类的成员 | ptr->member |
让我们看看一些用法：
#include <iostream>
using namespace std;
int main() {
int a = 10;
int* ptr = &a;
cout << "Size of int: " << sizeof(int) << " bytes" << endl;
cout << "Value of a: " << a << endl;
cout << "Address of a: " << &a << endl;
cout << "Value pointed by ptr: " << *ptr << endl;
int b = (a > 5) ? 1 : 0;
cout << "b = " << b << endl;
return 0;
}在这个魔法咒语中，我们使用了 sizeof 来获取 int 的大小，& 来获取 a 的地址，* 来解引用指针，以及三元运算符 ?: 作为 if-else 语句的简写。
Opérateurs de Précedence en C++
Comme dans les mathématiques, les opérateurs C++ ont une hiérarchie de précedence. Cela détermine l'ordre dans lequel les opérations sont effectuées dans une expression. C'est comme les règles du combat magique - certains sorts ont une précedence sur d'autres !
Voici un tableau simplifié de la précedence des opérateurs (de la plus haute à la plus basse) :
| Précedence | Opérateur |
|---|---|
| 1 | :: |
| 2 | () [] -> . ++ -- |
| 3 | ! ~ ++ -- + - * & (type) sizeof |
| 4 | * / % |
| 5 | + - |
| 6 | << >> |
| 7 | < <= > >= |
| 8 | == != |
| 9 | & |
| 10 | ^ |
| 11 | | |
| 12 | && |
| 13 | || |
| 14 | ?: |
| 15 | = += -= *= /= %= >>= <<= &= ^= |= |
| 16 | , |
N'oubliez pas, vous pouvez toujours utiliser des parenthèses pour ignorer la précedence par défaut et spécifier explicitement l'ordre des opérations.
Et voilà, jeunes magiciens ! Vous avez刚刚完成你们的C++操作符魔法第一课。 Souvenez-vous, la pratique fait parfait, donc continuez à jeter ces sorts de codage jusqu'à ce qu'ils deviennent naturels. Avant de savoir dire, vous serez en mesure de créer des programmes complexes avec facilité. Bonne programmation, et que vos erreurs de compilation soient rares et éloignées !
Credits: Image by storyset