Programmation C++/Les opérations de base

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche


Les C++ possède un grand nombre d'opérateurs de base effectuant entre autre des opérations arithmétiques et capables de travailler sur les entiers, les réels, etc... Nous allons présenter ici ces principaux opérateurs.

L'affectation[modifier | modifier le wikicode]

Syntaxe[modifier | modifier le wikicode]

identificateur=expression

Sémantique[modifier | modifier le wikicode]

On commence par évaluer l'expression et on met le résultat dans la variable identificateur.

Exemple[modifier | modifier le wikicode]

#include <iostream>
using namespace std;

int main()
{
    int a, b, s;
    cout << "Tapez la valeur de a : "; cin >> a;
    cout << "Tapez la valeur de b : "; cin >> b;

    s = a + b;  // affecter le résultat de l'addition à la variable s

    cout << "La somme a+b vaut : " << s << endl;
    return 0;
}

Exécution[modifier | modifier le wikicode]

Tapez la valeur de a : 45
Tapez la valeur de b : 67
La somme a+b vaut : 112

Explications[modifier | modifier le wikicode]

Dans ce programme, on déclare 3 variables a, b et s. On demande à l'utilisateur du programme de taper la valeur de a puis la valeur de b. cout sert à l'affichage à l'écran et cin à la saisie au clavier. Le programme calcule ensuite dans la variable s la somme a+b. On affiche finalement la valeur de s.

Affectation à la déclaration[modifier | modifier le wikicode]

L'affectation à la déclaration d'une variable est appelée "déclaration avec initialisation", car est un cas particulier de l'affectation (en particulier avec les objets).

Exemple :

int a = 57;

Affectation en série[modifier | modifier le wikicode]

Le résultat d'une même expression peut être assigné à plusieurs variables sans la réévaluer, en une seule instruction :

identificateur2=identificateur1=expression

Par exemple :

a = b = 38 + t;

En fait, l'affectation retourne une valeur : celle affectée à la variable. L'exemple précédent est donc équivalent à :

a = (b = 38 + t);

L'opération se déroule de la manière suivante :

  1. Le résultat de 38+t est calculé ;
  2. Il est affecté à la variable b ;
  3. Il est retourné par l'opérateur d'affectation ;
  4. Cette valeur retournée est affectée à la variable a.

Remarque importante[modifier | modifier le wikicode]

Pour effectuer un test de comparaison, par exemple comparer a à 53, il ne faut pas écrire if(a=53) mais if(a==53) en utilisant 2 fois le symbole =. Une erreur classique !

Opérations arithmétiques[modifier | modifier le wikicode]

sur les entiers[modifier | modifier le wikicode]

On peut effectuer les opérations arithmétiques usuelles sur les entiers en utilisant les opérateurs +, -, / et *. Il faut juste avoir en tête que la division sur les entiers effectue une troncature (la partie décimale est perdue). Le modulo s'obtient en utilisant l'opérateur %. Ainsi a%b désigne le reste de la division de a par b. On peut utiliser les parenthèses pour fixer l'ordre d'évaluation des expressions. On peut aussi utiliser l'opérateur ++ pour incrémenter une variable de 1. L'opérateur --, quant à lui, décrémente une variable de 1.

sur les réels[modifier | modifier le wikicode]

Sur les réels, on utilise les opérateurs +, -, * et / pour effectuer les 4 opérations de base. Il faut avoir en tête que toute opération sur les réels est entâchée d'une minuscule erreur de calcul : il s'agit d'un arrondi sur le dernier bit. Si on effectue de nombreux calculs, cette erreur peut s'amplifier et devenir extrêmement grande.

Les fonctions mathématiques habituelles sont présentes dans la bibliothèque standard <cmath>.

Exemple[modifier | modifier le wikicode]

#include <iostream>
using namespace std;

int main()
{
    int a, b, M;

    cout << "Tapez la valeur de a : "; cin >> a;
    cout << "Tapez la valeur de b : "; cin >> b;

    M = (a+3) * (6+a) + (b-5) * 2;

    cout << "M vaut " << M << endl;

    return 0;
}

Exécution :[modifier | modifier le wikicode]

Tapez la valeur de a : 1
Tapez la valeur de b : 2
M vaut 22

Opérations binaires[modifier | modifier le wikicode]

Les opérations présentées dans cette section opèrent au niveau des bits.

Les décalages[modifier | modifier le wikicode]

Les décalages permettent de décaler vers la droite ou vers la gauche toute la représentation en binaire d'une valeur d'un certain nombre de bits.

Syntaxe Sémantique
valeur << decalage Décale la valeur de decalage bits vers la gauche.
valeur >> decalage Décale la valeur de decalage bits vers la droite.

Exemple[modifier | modifier le wikicode]

#include <iostream>
using namespace std;

int main()
{
    int a = 5;
    int b;

    b = a << 3;
    cout<<"b vaut : "<<b<<endl;

    b = (a+1) << 3;
    cout<<"b vaut : "<<b<<endl;

    return 0;
}

Exécution[modifier | modifier le wikicode]

b vaut 40
b vaut 48

Le ET binaire[modifier | modifier le wikicode]

Syntaxe[modifier | modifier le wikicode]

exp1 & exp2

Sémantique[modifier | modifier le wikicode]

Le résultat est obtenu en faisant un ET logique sur chaque bit de la représentation de exp1 avec le bit correspondant de la représentation de exp2. Le ET logique a pour résultat 1 si les deux bits correspondants en entrée sont à 1 (pour 1-1), et sinon 0 (pour 0-1, 1-0 ou 0-0).

Exemple[modifier | modifier le wikicode]

#include <iostream>
using namespace std;

int main()
{
    int a = 53;
    int b = 167;
    int c = a & b;
    cout << "c vaut " << c << endl;

    return 0;
}

Exécution[modifier | modifier le wikicode]

c vaut 37

Explications[modifier | modifier le wikicode]

 53 s'écrit en binaire 0000 0000 0000 0000 0000 0000 0011 0101
167 s'écrit en binaire 0000 0000 0000 0000 0000 0000 1010 0111
ET binaire             0000 0000 0000 0000 0000 0000 0010 0101
==> le résultat vaut 37 en décimal

Le OU binaire[modifier | modifier le wikicode]

Syntaxe[modifier | modifier le wikicode]

exp1 | exp2

Sémantique[modifier | modifier le wikicode]

Le résultat est obtenu en faisant un OU logique sur chaque bit de la représentation de exp1 avec le bit correspondant de la représentation de exp2. Le OU logique a pour résultat 1 si l'un des deux bits correspondant en entrée est à 1 (pour 1-1, 1-0 ou 0-1), et sinon 0 (pour 0-0).

Exemple[modifier | modifier le wikicode]

#include <iostream>
using namespace std;

int main()
{
    int a = 53;
    int b = 167;
    int c = a | b;
    cout << "c vaut " << c << endl;

    return 0;
}

Exécution[modifier | modifier le wikicode]

c vaut 183

Explications[modifier | modifier le wikicode]

 53 s'écrit en binaire 0000 0000 0000 00000 0000 0000 0011 0101
167 s'écrit en binaire 0000 0000 0000 00000 0000 0000 1010 0111
OU binaire             0000 0000 0000 00000 0000 0000 1011 0111
==> le résultat vaut 183 en décimal

Le OU exclusif binaire[modifier | modifier le wikicode]

Syntaxe[modifier | modifier le wikicode]

exp1 ^ exp2

Sémantique[modifier | modifier le wikicode]

Le résultat est obtenu est faisant un OU exclusif sur chaque bit de la représentation de exp1 avec le bit correspondant de la représentation de exp2. Le OU exclusif logique a pour résultat 1 si les deux bits correspondant en entrée sont différents (pour 1-0 ou 0-1), et sinon 0 (pour 1-1 ou 0-0).

Exemple[modifier | modifier le wikicode]

#include <iostream>
using namespace std;

int main()
{
    int a = 53;
    int b = 167;
    int c = a ^ b;
    cout << "c vaut " << c << endl;

    return 0;
}

Exécution[modifier | modifier le wikicode]

c vaut 146

Explications[modifier | modifier le wikicode]

 53 s'écrit en binaire  0000 0000 0000 00000 0000 0000 0011 0101
167 s'écrit en binaire  0000 0000 0000 00000 0000 0000 1010 0111
OU exclusif binaire     0000 0000 0000 00000 0000 0000 1001 0010
==> le résultat vaut 146 en décimal

Le NON binaire[modifier | modifier le wikicode]

Syntaxe[modifier | modifier le wikicode]

~exp

Sémantique[modifier | modifier le wikicode]

Le résultat est obtenu en inversant tous les bits de la représentation de exp. Le 1 devient 0 et vice versa.

Exemple[modifier | modifier le wikicode]

#include <iostream>
using namespace std;

int main()
{
    int a = 53;
    int b = ~a;
    cout << "b vaut " << b << endl;
    return 0;
}

Exécution[modifier | modifier le wikicode]

b vaut -54

Explications[modifier | modifier le wikicode]

53 s'écrit en binaire   0000 0000 0000 0000 0000 0000 0011 0101
NON binaire             1111 1111 1111 1111 1111 1111 1100 1010
==> le résultat vaut -54 en décimal (signed int)
           ou 4294967242 (unsigned int)

Opérations booléennes[modifier | modifier le wikicode]

Comparaisons usuelles[modifier | modifier le wikicode]

Les comparaissons usuelles s'effectuent selon la syntaxe a symbole b, symbole désignant le test effectué :

  • Le symbole > désigne le test strictement supérieur à.
  • Le symbole >= désigne le test supérieur ou égal à.
  • Le symbole < désigne le test strictement inférieur à.
  • Le symbole <= désigne le test inférieur ou égal à.
  • Le symbole == désigne le test d'égalité.
  • Le symbole != désigne le test différent.

Le ET logique[modifier | modifier le wikicode]

Syntaxe[modifier | modifier le wikicode]

condition1 && condition2

Sémantique[modifier | modifier le wikicode]

Le ET logique est vrai si à la fois les condition1 et condition2 sont vraies. Il est faux dans le cas contraire.

Le OU logique[modifier | modifier le wikicode]

Syntaxe[modifier | modifier le wikicode]

condition1 || condition2

Sémantique[modifier | modifier le wikicode]

Le OU logique est vrai si au moins une des 2 conditions condition1 ou condition2 est vraie. Il est faux dans le cas contraire.

Le NON logique[modifier | modifier le wikicode]

Syntaxe[modifier | modifier le wikicode]

!(condition)

Sémantique[modifier | modifier le wikicode]

Le NON logique inverse la valeur de condition: si condition vaut true le résultat vaut false. Si condition vaut false le résultat vaut true.

Exemples d'utilisation des opérateurs booléens[modifier | modifier le wikicode]

bool b;
int u = 18;
b = !( (u>20 || (u<0)));

b vaut true.

bool b = ! false ; // -> b vaut true
b = ! true ; // -> b vaut false

Affectation avec opérateur[modifier | modifier le wikicode]

Il existe toute une gamme d'opérateurs permettant d'effectuer une opération (une addition par exemple) avec le contenu d'une variable et de mettre le résultat dans cette même variable. Ainsi il sera plus pratique d'écrire b += a ; que d'écrire b = b + a ;.

Une opération du type

a opérateur= expression ;

équivaut à :

a = a opérateur (expression) ;

L'opérateur +=[modifier | modifier le wikicode]

Syntaxe[modifier | modifier le wikicode]
identificateur+=expression
Sémantique[modifier | modifier le wikicode]

Cet opérateur ajoute à la variable identificateur la valeur de expression et stocke le résultat dans la variable identificateur.

Exemple[modifier | modifier le wikicode]
#include <iostream>

using namespace std;

int main()
{
    int a = 80;
    int b = 70;
    b += a;
    cout << "La valeur de b est : " << b << endl;
    return 0;
}
Exécution[modifier | modifier le wikicode]
La valeur de b est 150

Autres opérateurs[modifier | modifier le wikicode]

Sur le même modèle, on peut utiliser les opérateurs suivants : -=, *=, /=, %=, >>=,<<=, &=, |= et ^=.

Priorité des opérateurs[modifier | modifier le wikicode]

Comme en mathématique, tous les opérateurs n'ont pas la même priorité.

Par exemple, l'expression 1+2*3 retournera la valeur 7 car l'opérateur * a une plus grande priorité et est évalué avant l'opérateur +. L'expression est donc équivalent à 1+(2*3).

Les parenthèses permettent de modifier les priorités en encadrant ce qu'il faut évaluer avant. Ainsi l'expression (1+2)*3 retournera la valeur 9.

La liste complète des opérateurs du C++[modifier | modifier le wikicode]

La liste ci-dessous présente les différents opérateurs du C++ avec leur associativité dans l'ordre de leur priorité (du premier évalué au dernier). Les opérateurs situés dans le même bloc ont la même priorité. Les opérateurs en rouge ne peuvent être surchargés.

Opérateurs Description Associativité
:: Sélection d'un membre d'un espace de nom, ou d'un membre statique d'une classe de gauche à droite
()

[]
.
->

Parenthèses pour évaluer en priorité

Tableau
Sélection d'un membre par un identificateur (structures et objets)
Sélection d'un membre par un pointeur (structures et objets)

++ --

+ -
!      ~
(type)
*
&
sizeof
new
delete
delete[]

Incrémentation post ou pré-fixée

Opérateur moins unaire
Non logique et NON logique bit à bit
cast
Déréférencement
Référencement (adresse d'une variable)
Taille d'une variable / d'un type
Allocation mémoire
Libération mémoire
Libération mémoire d'un tableau

de droite à gauche
.*

->*

Déréférencement d'un pointeur de membre d'un objet

Déréférencement d'un pointeur de membre d'un objet pointé

de gauche à droite
* / % Multiplication, division, et modulo (reste d'une division)
+ - Addition et soustraction
<< >> Décalage de bits vers la droite ou vers la gauche
< <=

> >=

Comparaison “ inférieur strictement ” et “ inférieur ou égal ”

Comparaison “ supérieur strictement ” et “ supérieur ou égal ”

== != Condition “ égal ” et “ différent ”
& ET logique bit à bit
^ OU exclusif bit à bit
| OU logique bit à bit
&& ET logique booléen
|| OU logique booléen
c?t:f Opérateur ternaire de condition de droite à gauche
=

+= -=
*= /= %=
<<= >>=
&= ^= |=

Affectation

Affectation avec somme ou soustraction
Affectation avec multiplication, division ou modulo
Affectation avec décalage de bits
Affectation avec ET logique, OU logique ou OU exclusif bit à bit

, Séquence d'expressions de gauche à droite