C++
voorrang van de operator

Opmerkingen

Rekenkundige operatoren

Rekenkundige operatoren in C ++ hebben dezelfde prioriteit als in de wiskunde:

Vermenigvuldiging en deling hebben links associativiteit (wat betekent dat ze van links naar rechts worden geëvalueerd) en ze hebben een hogere prioriteit dan optellen en aftrekken, die ook links associativiteit hebben.

We kunnen ook de prioriteit van expressie afdwingen met haakjes ( ) . Net zoals je dat zou doen in de normale wiskunde.

// 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

Logische EN- en OF-operatoren

Deze operatoren hebben de gebruikelijke prioriteit in C ++: AND vóór OF.

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

Deze code is gelijk aan het volgende:

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

Het toevoegen van haakjes verandert het gedrag echter niet, maar het maakt het gemakkelijker om te lezen. Door deze haakjes toe te voegen bestaat er geen verwarring over de bedoeling van de schrijver.

Logisch && en || operators: kortsluiting

&& heeft voorrang op ||, dit betekent dat haakjes worden geplaatst om te evalueren wat samen zou worden geëvalueerd.

c ++ gebruikt kortsluitevaluatie in && en || geen onnodige executies uitvoeren.
Als de linkerkant van || geeft waar terug dat de rechterkant niet meer hoeft te worden geëvalueerd.

#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
}

Unaire operatoren

Unaire operatoren handelen op het object waarop ze worden aangeroepen en hebben een hoge prioriteit. (Zie opmerkingen)

Wanneer de postfix wordt gebruikt, vindt de actie pas plaats nadat de hele bewerking is geëvalueerd, wat tot een aantal interessante rekenkundige resultaten leidt:

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