サーチ…


備考

演算子は、降順で優先順位が上から下に表示されます。同じ番号を持つ演算子は、同じ優先順位と同じ結合性を持ちます。

  1. ::
  2. 後置演算子: [] () T(...) . -> ++ -- dynamic_cast static_cast reinterpret_cast const_cast typeid
  3. 単項接頭辞演算子: ++ -- * & + - ! ~ sizeof new delete delete[] 。 Cスタイルのキャスト記法、 (T)... ; (C ++ 11以上) sizeof... alignof noexcept
  4. .*->*
  5. */ 、および% 、バイナリ算術演算子
  6. +- 、2進算術演算子
  7. <<>>
  8. <><=>=
  9. ==!=
  10. & 、ビット単位のAND演算子
  11. ^
  12. |
  13. &&
  14. ||
  15. ?:三項条件演算子)
  16. =*=/=%=+=-=>>=<<=&=^=|=
  17. throw
  18. , (カンマ演算子)

代入、複合代入、三項条件演算子は右結合です。他のバイナリ演算子はすべて左結合です。

三項条件演算子のルールは、単純優先ルールよりも複雑です。

  • オペランドはあまり密接にバインドされてい?その左または上:その右の上の他のオペレータにより。事実上、条件演算子の第2オペランドはあたかもかっこのように解析されます。これにより、 a ? b , c : dは構文上有効です。
  • オペランドはより密接にaにバインドされ?代入演算子よりも右にあるか、左にthrowされるのでa = b ? c : da = (b ? c : d)相当しthrow a ? b : cthrow (a ? b : c)と同じthrow (a ? b : c)
  • オペランドはよりも、その右側に代入演算子をより強固に結合:その左に、そうa ? b : c = da ? b : (c = d)

算術演算子

C ++の算術演算子は、数学と同じ優先順位を持ちます。

乗算と除算は結合性(左から右に評価されることを意味する)を残しており、加算と減算よりも優先順位が高く、結合性も残っています。

また、括弧( )を使用して式の優先順位を強制することもできます。普通の数学でやっているのと同じように。

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

論理積AND演算子

これらの演算子は、C ++では通常の優先順位を持ちます。

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

このコードは、次のコードと同じです。

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

かっこを追加しても動作は変わりませんが、読みやすくなります。これらのカッコを追加することによって、作家の意図について混同することはありません。

論理&&と||演算子:短絡

&&は||よりも優先されます。これは、一緒に評価されるものを評価するためにかっこが配置されることを意味します。

c ++は&&および||で短絡評価を使用します。不必要な処刑をしない。
||の左辺ならば右側を評価する必要はありません。

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

単項演算子

単項演算子は、呼び出されたオブジェクトに作用し、優先順位が高くなります。 (備考参照)

postfixを使用すると、操作全体が評価された後にのみアクションが発生し、興味深い算術演算が行われます。

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
ライセンスを受けた CC BY-SA 3.0
所属していない Stack Overflow