C++
Operator Vorrang

Bemerkungen

Rechenzeichen

Arithmetische Operatoren in C ++ haben die gleiche Priorität wie in der Mathematik:

Multiplikation und Division haben Assoziativität hinterlassen (was bedeutet, dass sie von links nach rechts ausgewertet werden) und sie haben eine höhere Priorität als Addition und Subtraktion, die auch Assoziativität hinterlassen haben.

Wir können den Vorrang des Ausdrucks auch mit Klammern ( ) erzwingen. Genauso wie Sie das in der normalen Mathematik tun würden.

// 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 UND- und ODER-Operatoren

Diese Operatoren haben die übliche Priorität in C ++: AND vor 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;

Dieser Code entspricht dem folgenden:

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

Durch das Hinzufügen der Klammer wird das Verhalten nicht geändert, es wird jedoch einfacher lesbar. Durch das Hinzufügen dieser Klammern besteht keine Verwirrung hinsichtlich der Absicht des Verfassers.

Logisch && und || Betreiber: Kurzschluss

&& hat Vorrang vor ||, das bedeutet, dass Klammern gesetzt werden, um auszuwerten, was zusammen ausgewertet würde.

c ++ verwendet die Kurzschlussbewertung in && und || keine unnötigen Hinrichtungen durchführen.
Wenn die linke Seite von || Gibt true zurück, die rechte Seite muss nicht mehr ausgewertet werden.

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

Unäre Operatoren

Unäre Operatoren wirken auf das Objekt ein, auf das sie aufgerufen werden und haben eine hohe Priorität. (Siehe Anmerkungen)

Wenn Postfix verwendet wird, wird die Aktion erst ausgeführt, nachdem die gesamte Operation ausgewertet wurde, was zu einigen interessanten Arithmetiken führt:

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