Recherche…


Remarques

Les opérateurs sont listés de haut en bas, en ordre décroissant. Les opérateurs avec le même numéro ont la même priorité et la même associativité.

  1. ::
  2. Les opérateurs postfixés: [] () T(...) . -> ++ -- dynamic_cast static_cast reinterpret_cast const_cast typeid
  3. Les opérateurs de préfixe unaire: ++ -- * & + - ! ~ sizeof new delete delete[] ; la notation de style C, (T)... ; (C ++ 11 et supérieur) sizeof... alignof noexcept
  4. .* et ->*
  5. * , / et % , opérateurs arithmétiques binaires
  6. + et - , opérateurs arithmétiques binaires
  7. << et >>
  8. < , > , <= , >=
  9. == et !=
  10. & , l'opérateur ET binaire
  11. ^
  12. |
  13. &&
  14. ||
  15. ?: (opérateur conditionnel ternaire)
  16. = , *= , /= , %= , += , -= , >>= , <<= , &= , ^= , |=
  17. throw
  18. , (l'opérateur de virgule)

L'attribution, l'assignation composée et les opérateurs conditionnels ternaires sont associatifs à droite. Tous les autres opérateurs binaires sont associatifs à gauche.

Les règles pour l'opérateur conditionnel ternaire sont un peu plus compliquées que les simples règles de priorité peuvent exprimer.

  • Un opérande se lie moins à un ? à sa gauche ou a : à sa droite que pour tout autre opérateur. Effectivement, le deuxième opérande de l'opérateur conditionnel est analysé comme s'il était entre parenthèses. Cela permet une expression telle que a ? b , c : d être syntaxiquement valide.
  • Un opérande se lie plus étroitement à un ? sur son droit qu'à un opérateur d'affectation ou throw sur sa gauche, donc a = b ? c : d est équivalent à a = (b ? c : d) et throw a ? b : c équivaut à throw (a ? b : c) .
  • Un opérande se lie plus étroitement à un opérateur d'affectation à sa droite qu'à : à sa gauche, donc a ? b : c = d est équivalent à a ? b : (c = d) .

Opérateurs arithmétiques

Les opérateurs arithmétiques en C ++ ont la même priorité qu'en mathématiques:

La multiplication et la division ont laissé une associativité (signifiant qu'elles seront évaluées de gauche à droite) et elles ont une priorité plus élevée que l'addition et la soustraction, qui ont également une associativité.

On peut aussi forcer la préséance de l'expression en utilisant des parenthèses ( ) . Tout comme vous le feriez en mathématiques normales.

// volume of a spherical shell = 4 pi R^3 - 4 pi r^3
double vol = 4.0*pi*R*R*R/3.0 - 4.0*pi*r*r*r/3.0;

//Addition:

int a = 2+4/2;          // equal to: 2+(4/2)         result: 4
int b = (3+3)/2;        // equal to: (3+3)/2         result: 3

//With Multiplication

int c = 3+4/2*6;        // equal to: 3+((4/2)*6)     result: 15
int d = 3*(3+6)/9;      // equal to: (3*(3+6))/9     result: 3

//Division and Modulo

int g = 3-3%1;          // equal to: 3 % 1 = 0  3 - 0 = 3
int h = 3-(3%1);        // equal to: 3 % 1 = 0  3 - 0 = 3
int i = 3-3/1%3;        // equal to: 3 / 1 = 3  3 % 3 = 0  3 - 0 = 3
int l = 3-(3/1)%3;      // equal to: 3 / 1 = 3  3 % 3 = 0  3 - 0 = 3
int m = 3-(3/(1%3));    // equal to: 1 % 3 = 1  3 / 1 = 3  3 - 3 = 0

Opérateurs logiques ET et OU

Ces opérateurs ont la priorité habituelle en C ++: AND avant OR.

// You can drive with a foreign license for up to 60 days
bool can_drive = has_domestic_license || has_foreign_license && num_days <= 60;

Ce code est équivalent à ce qui suit:

// You can drive with a foreign license for up to 60 days
bool can_drive = has_domestic_license || (has_foreign_license && num_days <= 60);

L'ajout de parenthèses ne modifie pas le comportement, cependant, il facilite la lecture. En ajoutant ces parenthèses, il n'y a aucune confusion quant à l'intention de l'auteur.

Logique && et || opérateurs: court-circuit

&& a préséance sur ||, cela signifie que les parenthèses sont placées pour évaluer ce qui serait évalué ensemble.

c ++ utilise l'évaluation des courts-circuits dans && et || ne pas faire d'exécutions inutiles.
Si le côté gauche de || renvoie vrai le côté droit n'a plus besoin d'être évalué.

#include <iostream>
#include <string>

using namespace std;

bool True(string id){
    cout << "True" << id << endl;
    return true;
}

bool False(string id){
    cout << "False" << id << endl;
    return false;
}


int main(){
    bool result;
    //let's evaluate 3 booleans with || and && to illustrate operator precedence
    //precedence does not mean that && will be evaluated first but rather where    
    //parentheses would be added
    //example 1
    result =
        False("A") || False("B") && False("C"); 
                // eq. False("A") || (False("B") && False("C"))
    //FalseA
    //FalseB
    //"Short-circuit evaluation skip of C"
    //A is false so we have to evaluate the right of ||,
    //B being false we do not have to evaluate C to know that the result is false
    

    
    result =
        True("A") || False("B") && False("C"); 
                // eq. True("A") || (False("B") && False("C"))
    cout << result << " :=====================" << endl;
    //TrueA
    //"Short-circuit evaluation skip of B"
    //"Short-circuit evaluation skip of C"
    //A is true so we do not have to evaluate 
    //        the right of || to know that the result is true
    //If || had precedence over && the equivalent evaluation would be:
    // (True("A") || False("B")) && False("C")
    //What would print
    //TrueA
    //"Short-circuit evaluation skip of B"
    //FalseC
    //Because the parentheses are placed differently 
    //the parts that get evaluated are differently
    //which makes that the end result in this case would be False because C is false
}

Opérateurs Unaires

Les opérateurs unaires agissent sur l'objet sur lequel ils sont appelés et ont la priorité. (Voir remarques)

Lorsqu'elle est utilisée postfixe, l'action se produit uniquement après l'évaluation de toute l'opération, ce qui conduit à des calculs arithmétiques intéressants:

int a = 1;
++a;            // result: 2
a--;            // result: 1
int minusa=-a;  // result: -1

bool b = true;
!b; // result: true

a=4;
int c = a++/2;      // equal to: (a==4) 4 / 2   result: 2 ('a' incremented postfix)
cout << a << endl;  // prints 5!
int d = ++a/2;      // equal to: (a+1) == 6 / 2 result: 3

int arr[4] =  {1,2,3,4};

int *ptr1 = &arr[0];    // points to arr[0] which is 1
int *ptr2 = ptr1++;     // ptr2 points to arr[0] which is still 1; ptr1 incremented
std::cout << *ptr1++ << std::endl;  // prints  2

int e = arr[0]++;       // receives the value of arr[0] before it is incremented
std::cout << e << std::endl;      // prints 1
std::cout << *ptr2 << std::endl;  // prints arr[0] which is now 2


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow