Cours de C++ — 2. Opérateurs en C++

Faire des commentaires en C++

Un bon programme est un programme commenté, ne l’oubliez jamais !!! Cela fait parti des commandements du bon programmeur !!! Alors comment commenter un programme ?
Pour commenter un programme, il existe deux méthodes :
– pour faire un commentaire sur une ligne on utilise //
– pour faire un commentaire sur une ou plusieurs ligne on utilise /* en début de commentaire et */
en fin de commentaire. Voici un exemple :

/****************************************
*   ceci est le premier programme C++	*
*   de math-linux.com . 		*
*****************************************/
// les programmeurs ajoutent des étoiles avec pour faire des jolis cadres !!!
/*
Il affiche à  l'écran
    My first program in C++
*/
//Début de programme
#include <iostream>
using namespace std;
main()
{
cout << "My first program in C++";// affiche un message sur la console

}
//Fin du programme

Les opérateurs d’assignation = et ()

L’opérateur = permet d’attribuer une valeur à l’opérande de gauche (communément appelé lvalue). Dans l’exemple suivant :

float p = 3.71;

p est l’opérande de gauche et 3.71 est la valeur qu’on lui attribue (rvalue). La commande qui suit

3=x;

renverra une erreur lors de la compilation, puisque 3 n’est pas une variable, autrement dit l’assignation d’une valeur à une variable n’est pas symétrique comme en mathématique.

Pour assigner une valeur à une variable , on utilise également l’opérateur () :

float q(3.71);

Les opérateurs booléens

Nous avons vu précédemment la définition d’opérateurs booléens.
Rappelez vous il existe en C++ 6 opérateurs nécessitant 2 opérandes :
– un opérande de gauche
– un opérateur de droite

Voici un exemple de définition de booléen :

#include <iostream>
using namespace std;

main()
{
int a = 1, b = 2;
bool b1(a == b);
bool b2 = (a == b);
}

b1 et b2 sont deux booléens de màªme valeur à savoir 0 puisque les variables a et b ne sont pas
égales. Rappelez-vous il existe deux manières d’initialiser une variable :
– l’opérateur () utilisé pour définir b1 par exemple
– l’opérateur = pour définir b2

Remarque. à‰vitez de confondre les opérateurs = et ==. Vous seriez bien surpris :
s’il l’on définit un booléen b3 comme suit :

bool b3(a=b);

alors b3 vaut 1 !!! Pourquoi ? a=b entraine que a vaut 2, cela veut dire donc que b3 est initialisé à 2, donc b3 vaut 1 puisqu’un booléen ne peut prendre que les valeurs 0 ou 1, car un booléen de valeur entière non nulle vaut toujours 1. (cf introduction). On voit donc qu’au final
que les opérateurs = et == n’ont pas du tout la màªme signification. Donc faites très attention !!!

Les opérateurs mathématiques classiques

Il existe en C++ cinq opérateurs mathématiques de base. Il s’agit des opérateurs arithmétiques suivant :
– l’addition +
– la soustraction -
– la multiplication *
– la division /
– le modulo % pour les nombres entiers, a%b est le reste de la division entière de a par b

Ce sont des opérateurs arithmétiques, ils possèdent donc les propriétés de priorité classique des mathématiques. à€ noter, que l’on est dans l’obligation d’indiquer ces opérateurs, il arrive parfois qu’en
mathématique, on omette le signe de multiplication, en C++ on doit à tout pris le mettre !!! Par exemple

int a= 2(3-2);

entrainera une erreur de compilation, il est plus correct de mettre

int a= 2*(3-2);

Remarque. Faites attention lorsque vous utilisez l’opérateur de division / ; en effet l’instruction suivante

int a = 3/2;

initialise la variable a à 1. à€ 1 car rappellez vous, a est un entier certes, mais la raison est que 3 et 2 sont des entiers, et a fortirori la division entière de 3 par 2 (le quotient si vous préférez !!!) est 1.

float a = 3/2;
cout << a;

affichera 1 ... Eh oui, 3 et 2 sont considérés comme des entiers et donc 3/2=1 (en C++) , donc a vaut 1.
Pour pallier à ce genre de problème, lorsque vous manipulez des réels de type float ou double par exemple, utilisez la ponctuation numérique :

float a = 3./2.;
cout << a;

le résultat est bien 1.5. Donc n’oubliez pas, utilisez le point lorsque vous avez des objets numériques autres que des entiers, écrivez 2. ou 2.0 au lieu de 2.

Les opérateurs d’incrémentation ++ et - -

Il exsite en C++ des opérateurs ++ préfixé et suffixé. Ils permettent d’incrémenter une variable d’une unité (de 1). L’opérateur suffixé ++ est défini comme suit :

int k = 254;
k++;
cout << k;

ce bout de code affichera 255. L’opérateur préfixé est lui défini de la manière suivante :

int l = 254;
++l;
cout << l;

ce bout de code affichera également 255. Alors quelle est la différence ?
il s’agit de l’assignation prioritaire ... Regardons le code suivant :

int m,n, var1, var2;
m = n = 254;
var1 = m++;
var2 = ++n;
cout << "var1:=" << var1 <<"; m=" << m <<endl;
cout << "var2:=" << var2 <<"; n=" << n <<endl;

Le résultat est le suivant :

var1:=254; m=255
var2:=255; n=255

dans le cas suffixé m++ l’assignation est prioritaire, puisque var1 vaut 254. Dans le cas préfixé, l’incrémentation est prioritaire. Toute est une question de priorité !!! à€ noter que, l’opérateur ++ est en général utilisé avec des entiers, mais rien n’empàªche de l’utiliser avec d’autres types :

float C = 21.0;
C++;

Il existe également un opérateur - - qui permet de retirer une unité à une variable donnée :

int m,n, var1, var2;
m = n = 254;
var1 = m--;
var2 = --n;
cout << "var1:=" << var1 <<"; m=" << m <<endl;
cout << "var2:=" << var2 <<"; n=" << n <<endl;

Le résultat est le suivant :

var1:=254; m=253
var2:=253; n=253

Assignation et opérations mathématiques en C++

Il est possible d’assigner et de faire des opérations mathématiques en màªme temps, c’est le cas notamment quand la rvalue et la lvalue dépendent d’une màªme variable. On peut par exemple remplacer le code suivant :

float x=2;
x=x+2;
x=2*x;
x=x-8;
x=x/2;

par

float x=2;
x+=2;
x*=2;
x-=8;
x/=2;

Les opérateurs +=, -=, *= et /= permettent donc de faire des opérations mathématiques et en màªme temps d’assigner des variables. On peut ajouter l’opérateur %= pour les entiers.

Les opérateurs logiques

Nous allons voir à présent les opérateurs logiques, ces derniers vont nous permettre de relier des expressions booléennes entre elles. Voici les principaux opérateurs logiques du C++ :

L’opérateur && renvoie 1 si et seulement si les deux opérandes vallent 1.
L’opérateur || renvoie 1 si et seulement si au moins une des opérandes vaut 1.
Enfin l’opérateur ! renvoie 1 si l’opérande est 0 et inversement il renvoie 0 s’il l’opérande est 1.

Regardons quelques exemples :

int k = 36;
bool b = (k % 2 == 0) &&  (k < 100);
cout << "b:=" << b << endl;

En sortie, on aura

b:=1

k % 2 == 0 renvoie 1 puisque le reste de la division de k par 2 est 0, c’est une manière détournée de savoir si k est pair, et c’est le cas ici. k < 100, c’est le cas donc (1 && 1) renvoie 1 donc b=1.

Un autre exemple

int m = 36;
bool b2 = (m > 1000) ||  3.14;
cout << "b2:=" << b2 << endl;

En sortie, on aura

b2:=1

m > 1000 renvoie clairement 0, mais 3.14 renvoie 1 puisque comme 3.14 est non nul, sa valeur est converti à 1 (rappelez vous c’est au dessus !!!). Par conséquent 0 || 1 entraà®ne que b2=1.

Pour terminer cette section, je terminerai par une notion fondamentale dans le cadre de l’optimisation de
code C++. Il s’agit de l’évaluation paresseuse (lazy evaluation). Lorsque vous avez plusieurs booléens reliés
par des opérateurs logiques, une question se pose comment le compilateur évalue-t-il ces expressions ?
En fait, il évalue de manière paresseuse, regardons l’exemple suivant :

bool b3 = (1==1) || (m > 1000) ||  3.14;

le compilateur va seulement évalué (1==1) puisque c’est vrai , il ne se préocuppe pas des autres booléens
puisqu’il n’y a que des opérateurs OU (||) et donc a priori il sait que le résultat sera 1 d’avance puisque il y a au moins une des expressions qui est vraie. De màªme que dans l’exemple suivant

bool b4 = (0==1) && (m > 1000) &&  3.14;

il n’évaluera que (0=1) puisque c’est faux , il ne se préocuppera pas des autres expressions booléennes.
Vous en convenez que dans le cadre de l’optimisation de code cela peut-àªtre intéressant, car pour l’opérateur ||, on placera les expressions booléénnes qui ont le plus de chance d’àªtre vraies pour augmenter la vitesse de l’exécution du code. Inversement pour l’opérateur &&, on placera les expressions booléennes qui ont le plus de chance d’àªtre fausses.

Conclusion

Les points importants de ce chapitre sont les suivants :
– un bon programme est un programme commenté
– les opérateurs sont des objets essentiels du C++
– pour assigner une variable on utilise les opérateurs = et ()
– Ne confondez pas l’opérateur booléen == et l’opérateur d’assignation =
– il existe 5 opérateurs mathématiques en C++ : +,-,*,/ et %
– Faites attention à la division entière !!!
– il existe des opérateurs d’incrémentation ++ et - - préfixés et suffixés
– l’opérateur préfixé est prioritaire sur l’opérateur d’assignation
– on peut conjuguer assignation et opération mathématiques en C++
à l’aide des opérateurs +=,-=,*=,/=, %= ; %= étant exclusivement dédié aux entiers
– les opérateurs logiques et leur évaluation paresseuse

Le prochain chapitre traitra des structures de contrà´le du C++.