Opérateurs C++

Introduction

Dans ce laboratoire, vous allez apprendre à utiliser les opérateurs en C++. Vous allez apprendre à utiliser les opérateurs arithmétiques, les opérateurs relationnels, les opérateurs logiques et les opérateurs bit-à-bit.

Skills Graph

Aperçu du contenu

Pour les données numériques et logiques de base, nous utilisons des opérateurs pour les manipuler. Comme dans les autres langages, C++ offre un support complet pour les opérateurs. Commencez à les apprendre.

• Opérations arithmétiques
• Opérations de type mixte
• Opérateurs d'affectation composée
• Conversion de type
• Opérateurs relationnels et logiques

Opérations arithmétiques

C++ prend en charge les opérateurs arithmétiques suivants pour les nombres :

Tous les opérateurs ci-dessus sont des opérateurs binaires, ils prennent deux opérandes. La multiplication, la division et le reste ont préférence sur l'addition et la soustraction.

Il est important de noter que int/int produit un int, avec le résultat tronqué, 1/2 → 0 (pas 0,5).

Opérations de type mixte

Si les deux opérandes d'une opération arithmétique appartiennent au même type, l'opération est effectuée dans ce type, et le résultat appartient à ce type. Cependant, si les deux opérandes appartiennent à des types différents, le compilateur promeut la valeur du type plus petit au type plus grand (connu sous le nom de type-cast implicite). L'opération est ensuite effectuée dans le type plus grand.

Par exemple

/* Testing mix-type arithmetic operations */
#include <iostream>
#include <iomanip>   // needed for formatting floating-point numbers
using namespace std;

int main() {
   int i1 = 2, i2 = 4;
   double d1 = 2,5, d2 = 5,0;

   // floating-points in fixed format with 1 decimal place
   cout<<fixed<<setprecision(1);

   cout << i1 << " + " << i2 << " = " << i1+i2 << endl;  // 6
   cout << d1 << " + " << d2 << " = " << d1+d2 << endl;  // 7,5
   cout << i1 << " + " << d2 << " = " << i1+d2 << endl;  // 7,0  <==

   cout << i1 << " - " << i2 << " = " << i1-i2 << endl;  // -2
   cout << d1 << " - " << d2 << " = " << d1-d2 << endl;  // -2,5
   cout << i1 << " - " << d2 << " = " << i1-d2 << endl;  // -3,0 <==

   cout << i1 << " * " << i2 << " = " << i1*i2 << endl;  // 8
   cout << d1 << " * " << d2 << " = " << d1*d2 << endl;  // 12,5
   cout << i1 << " * " << d2 << " = " << i1*d2 << endl;  // 10,0 <==

   cout << i1 << " / " << i2 << " = " << i1/i2 << endl;  // 0    <==
   cout << d1 << " / " << d2 << " = " << d1/d2 << endl;  // 0,5
   cout << i1 << " / " << d2 << " = " << i1/d2 << endl;  // 0,4  <==
   return 0;
}

Sortie :

2 + 4 = 6
2,5 + 5,0 = 7,5
2 + 5,0 = 7,0
2 - 4 = -2
2,5 - 5,0 = -2,5
2 - 5,0 = -3,0
2 * 4 = 8
2,5 * 5,0 = 12,5
2 * 5,0 = 10,0
2 / 4 = 0
2,5 / 5,0 = 0,5

Débordement / Sous-débordement

// Range of int is [-2147483648, 2147483647]
   int i1 = 2147483647;      // max int
   cout << i1 + 1 << endl;   // -2147483648 (overflow)
   cout << i1 * i1 << endl;  // 1

   int i2 = -2147483648;     // min int
   cout << i2 - 1 << endl;   // 2147483647 (underflow)
   cout << i2 * i2 << endl;  // 0

Dans les opérations arithmétiques, la valeur résultante reprend si elle dépasse sa plage. Le runtime C++ ne génère pas de message d'erreur/alerte mais produit un résultat incorrect. Il est important de noter que il incombe au programmeur de vérifier le débordement/sous-débordement.

Opérateurs d'affectation composée

C++ fournit également les soi-disant opérateurs d'affectation composée tels que suivants :

x = 5;
cout << x++ << endl;  // Sauvegarde x (5) ; Incrémente x (=6) ; Affiche l'ancienne valeur de x (5).
x = 5;
cout << ++x << endl;  // Incrémente x (=6) ; Affiche x (6).

Conversion de type implicite vs. Type-cast explicite

Lorsque vous affectez une valeur d'un type fondamental (intégré) à une variable d'un autre type fondamental, C++ convertit automatiquement la valeur au type de réception, si les deux types sont compatibles. Par exemple :

• Si vous affectez une valeur int à une variable double, le compilateur convertit automatiquement la valeur int en double (par exemple, de 1 à 1,0) et l'affecte à la variable double.
• Si vous affectez une valeur double à une variable int, le compilateur convertit automatiquement la valeur double en valeur int (par exemple, de 1,2 à 1) et l'affecte à la variable int. La partie fractionnaire sera tronquée et perdue. Certains compilateurs émettent une alerte/erreur "perte possible de précision" ; d'autres ne le font pas.

 int i;
 double d;

 i = 3;
 d = i;    // Affecte une valeur int à double
 cout << "d = " << d << endl;  // 3,0

 d = 5,5;
 i = d;    // Affecte une valeur double à int
 cout << "i = " << i << endl;  // 5 (tronqué, pas d'alerte!)

Vous pouvez effectuer explicitement un type-cast via le soi-disant opérateur unaire de type-cast sous la forme (nouveau-type) opérande ou nouveau-type (opérande). L'opérateur de type-cast prend un opérande dans le type particulier et renvoie une valeur équivalente dans le nouveau type. Notez que c'est une opération qui produit une valeur résultante, similaire à une opération d'addition bien que l'addition implique deux opérandes. Par exemple :

cout << (double)5 << endl;  // int 5 → double 5,0
cout << (int)5,5 << endl;   // double 5,5 → int 5

double aDouble = 5,6;
int anInt = (int)aDouble; // renvoie 5 et l'affecte à anInt. aDouble ne change pas!

// C++ prend également en charge le type-cast de style fonction.
cout << double(5) << endl;     // 5,0
cout << int(5,5) << endl;      // 5
cout << int(aDouble) << endl;  // 5

Opérateurs relationnels et logiques

Très souvent, vous devez comparer deux valeurs avant de décider de l'action à entreprendre. C++ fournit six opérateurs de comparaison (ou opérateurs relationnels) :

Les tables de vérité sont les suivantes :

// Retourne vrai si x est compris entre 0 et 100 (inclus)
(x >= 0) && (x <= 100)
// Faux d'utiliser 0 <= x <= 100

// Retourne vrai si x est en dehors de 0 et 100 (inclus)
(x < 0) || (x > 100)   //ou
!((x >= 0) && (x <= 100))

// Retourne vrai si year est une année bissextile
// Une année est bissextile si elle est divisible par 4 mais pas par 100, ou si elle est divisible par 400.
((year % 4 == 0) && (year % 100!= 0)) || (year % 400 == 0)

Sommaire

Cette partie est relativement facile, vous devriez la relier à la section précédente. Il n'est pas nécessaire de la mémoriser, il suffit de comprendre sa logique.