수색…


비고

연산자는 내림차순으로 위에서 아래로 나열됩니다. 동일한 수의 연산자는 동일한 우선 순위와 같은 연관성을 갖습니다.

  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. +- , 이진 산술 연산자
  7. <<>>
  8. < , > , <= , >=
  9. ==!=
  10. & , 비트 AND 연산자
  11. ^
  12. |
  13. &&
  14. ||
  15. ?: (3 진 조건부 연산자)
  16. = , *= , /= , %= , += , -= , >>= , <<= , &= , ^= |=
  17. throw
  18. , (쉼표 연산자)

할당, 복합 할당 및 삼항 조건 연산자는 오른쪽 연관입니다. 다른 모든 2 진 연산자는 왼쪽 연관입니다.

삼항 조건부 연산자에 대한 규칙은 간단한 우선 순위 규칙이 표현할 수있는 것보다 약간 더 복잡합니다.

  • 피연산자는 a에 덜 엄격하게 바인딩 ? 왼쪽 또는 오른쪽 : 다른 운영자보다. 효과적으로 조건부 연산자의 두 번째 피연산자는 괄호로 처리 된 것처럼 구문 분석됩니다. 이것은 a ? b , c : d 는 구문 적으로 유효합니다.
  • 피연산자가 a에 더 밀접하게 바인딩 ? 할당 연산자보다 오른쪽에 있거나 왼쪽에 throw 때문에 a = b ? c : da = (b ? c : d) 와 같고 throw a ? b : cthrow (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 및 OR 연산자

이러한 연산자는 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 ++는 && 및 ||에서 단락 회로 평가를 사용합니다. 불필요한 처형은하지 말라.
| 왼쪽면 || 오른쪽을 반환하면 true를 반환하므로 더 이상 평가할 필요가 없습니다.

#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