C++ 연산자 우선순위 | "Operator Precedence" 가이드

연산자 우선순위란?

여러 연산자가 함께 사용될 때 실행 순서

int x = 2 + 3 * 4;  // 14 (곱셈 먼저)
int y = (2 + 3) * 4;  // 20 (괄호 먼저)

우선순위 표 (높음 → 낮음)

아래는 C++에서 자주 쓰는 연산자를 우선순위가 높은 것이 위로 오도록 묶은 요약입니다. 세부 우선순위는 cppreference 연산자 우선순위와 완전히 동일하진 않을 수 있으니, 애매하면 괄호를 쓰세요.

우선순위(대략)	연산자	결합 방향	메모
최상	::	왼쪽→오른쪽	범위 지정
높음	a++, a--, a(), a[], ., ->	—	후위, 호출, 첨자
	++a, --a, +a, -a, !, ~, (type), *a, &a, sizeof, co_await	오른쪽→왼쪽	단항
	.*, ->*	왼쪽→오른쪽	멤버 포인터
	*, /, %	왼쪽→오른쪽	곱·나눗셈
	+, -	왼쪽→오른쪽	덧셈·뺄셈
	<<, >>	왼쪽→오른쪽	시프트 (+보다 위)
	<, <=, >, >=	왼쪽→오른쪽	비교
	==, !=	왼쪽→오른쪽	동등
	&	왼쪽→오른쪽	비트 AND
	^	왼쪽→오른쪽	비트 XOR
	비트 OR	왼쪽→오른쪽	한 글자짜리 세로 막대 두 개 (a와 b의 비트 OR)
	&&	왼쪽→오른쪽	논리 AND
	논리 OR	왼쪽→오른쪽	두 세로 막대 연산자(짧은 서킷 논리합)
낮음	?:	오른쪽→왼쪽	삼항
	=, +=, -=, …	오른쪽→왼쪽	대입
	,	왼쪽→오른쪽	쉼표

비트 연산자가 함정인 이유: ==와 !=는 &보다 위에 있지만, &는 &&보다 위입니다. 그래서 flags & MASK == 0은 (flags & (MASK == 0))가 되어 의도와 다릅니다.

// 1. 후위 연산자
a++, a--, a[i], a(args), a.b, a->b

// 2. 단항 연산자
++a, --a, +a, -a, !a, ~a, *a, &a, sizeof

// 3. 곱셈/나눗셈/나머지
a * b, a / b, a % b

// 4. 덧셈/뺄셈
a + b, a - b

// 5. 비트 시프트
a << b, a >> b

// 6. 비교 연산자
a < b, a <= b, a > b, a >= b

// 7. 동등 비교
a == b, a != b

// 8. 비트 AND
a & b

// 9. 비트 XOR
a ^ b

// 10. 비트 OR
a | b

// 11. 논리 AND
a && b

// 12. 논리 OR
a || b

// 13. 삼항 연산자
a ? b : c

// 14. 대입 연산자
a = b, a += b, a -= b, a *= b, a /= b

결합 방향(associativity) 정리

• 왼쪽 결합(대부분의 이항 연산자): a - b - c는 (a - b) - c입니다.
• 오른쪽 결합: 단항 연산자 일부, 대입 a = b = c는 a = (b = c), 삼항의 중첩도 오른쪽 결합으로 해석됩니다.
• 시프트와 덧셈: 1 << 2 + 3은 시프트보다 +가 먼저라 1 << (2 + 3) 입니다. 비트 마스크 만들 때 자주 헷갈립니다.

흔한 실수: 비트 연산 중심

• 마스크 검사: if (flags & MASK == 0) 금지 → if ((flags & MASK) == 0).
• 시프트 + 산술: 원하는 게 (1 << n) - 1이면 반드시 괄호.
• 부호 있는 타입과 시프트: 구현 정의·미정 동작이 될 수 있으므로 마스크는 가능하면 부호 없는 정수로 (size_t 등).

괄호 사용 가이드

• 의도가 표준 우선순위에 의존하는지 동료가 바로 알 수 있으면 괄호는 생략 가능(예: 단순 a * b + c).
• 비트·시프트·비교·논리가 한 줄에 섞이면 항상 괄호를 권장합니다.
• 매크로를 쓸 때는 인자마다 괄호로 감싸는 것이 기본입니다(우선순위 버그 방지).

실전 팁

• 조건문에서는 널 포인터·범위 검사를 &&의 왼쪽에 두어 단축 평가로 안전하게(이미 본문 “단축 평가” 절과 연결).
• 리뷰 시 복잡한 조건식은 중간 bool 변수로 이름을 붙이면 우선순위 논쟁 자체가 사라집니다.

실전 예시

예시 1: 산술 연산

int a = 2 + 3 * 4;      // 14 (* 먼저)
int b = 10 - 2 + 3;     // 11 (왼쪽부터)
int c = 10 / 2 * 3;     // 15 (왼쪽부터)
int d = 2 * 3 + 4 * 5;  // 26 (* 먼저, + 나중)

// 괄호로 명확히
int e = (2 + 3) * 4;    // 20
int f = 2 * (3 + 4);    // 14

예시 2: 비교 연산

bool a = 5 > 3 && 2 < 4;   // true (비교 먼저, && 나중)
bool b = 5 > 3 || 2 > 4;   // true (비교 먼저, || 나중)
bool c = !false && true;   // true (! 먼저)

// 복잡한 조건
int x = 10;
bool result = x > 5 && x < 15 || x == 20;
// (x > 5 && x < 15) || (x == 20)

예시 3: 비트 연산

int a = 1 | 2 & 4;   // 1 (& 먼저, | 나중)
int b = 1 | (2 & 4); // 1 (명시적)
int c = (1 | 2) & 4; // 0 (명시적)

// 시프트 연산
int d = 1 << 2 + 1;  // 8 (+ 먼저, << 나중)
int e = (1 << 2) + 1; // 5 (명시적)

예시 4: 증감 연산자

int x = 5;
int a = x++ * 2;  // 10 (x는 후위 증가)
// x는 이제 6

int y = 5;
int b = ++y * 2;  // 12 (y는 전위 증가)
// y는 이제 6

int z = 5;
int c = z++ + ++z;  // 5 + 7 = 12
// z는 이제 7

결합성 (Associativity)

// 왼쪽 결합 (대부분)
int a = 10 - 5 - 2;  // (10 - 5) - 2 = 3

// 오른쪽 결합 (대입, 단항)
int x, y, z;
x = y = z = 10;  // x = (y = (z = 10))

int b = 2;
int c = ++b + ++b;  // 오른쪽부터

자주 발생하는 실수

실수 1: 비트 연산과 비교

// ❌ 의도와 다름
if (flags & MASK == 0) {
    // flags & (MASK == 0) 로 해석됨
}

// ✅ 괄호 사용
if ((flags & MASK) == 0) {
    // 올바른 의도
}

실수 2: 논리 연산 순서

// ❌ 의도와 다름
if (ptr != nullptr && *ptr == 10) {
    // 올바름 (&& 전에 != 먼저)
}

// ❌ 잘못된 순서
if (*ptr == 10 && ptr != nullptr) {
    // ptr이 nullptr이면 크래시!
}

실수 3: 대입과 비교

int x = 5;

// ❌ 대입 (항상 true)
if (x = 10) {
    cout << "x는 " << x << endl;  // 10
}

// ✅ 비교
if (x == 10) {
    cout << "x는 10" << endl;
}

실수 4: 증감 연산자

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

// ❌ 정의되지 않은 동작
int x = arr[i] + arr[i++];

// ✅ 명확하게 분리
int x = arr[i];
i++;
x += arr[i];

괄호 사용 권장

// 복잡한 표현식은 괄호로 명확히
bool result = (a > b) && (c < d) || (e == f);

// 비트 연산은 항상 괄호
if ((flags & MASK) != 0) {
    // ...
}

// 시프트 연산도 괄호
int value = (1 << bits) - 1;

실용 예시

예시 1: 플래그 체크

const int READ = 1;
const int WRITE = 2;
const int EXECUTE = 4;

int permissions = READ | WRITE;

// 읽기 권한 체크
if ((permissions & READ) != 0) {
    cout << "읽기 가능" << endl;
}

// 쓰기 권한 체크
if ((permissions & WRITE) != 0) {
    cout << "쓰기 가능" << endl;
}

// 실행 권한 체크
if ((permissions & EXECUTE) == 0) {
    cout << "실행 불가" << endl;
}

예시 2: 범위 체크

int x = 50;

// 범위 체크 (괄호 불필요하지만 명확)
if (x >= 0 && x <= 100) {
    cout << "범위 내" << endl;
}

// 복잡한 조건
if ((x > 10 && x < 20) || (x > 30 && x < 40)) {
    cout << "특정 범위" << endl;
}

예시 3: 계산식

// 수학 공식
double result = a * x * x + b * x + c;

// 명확한 괄호
double result2 = (a * x * x) + (b * x) + c;

// 평균 계산
double avg = (a + b + c) / 3.0;

단축 평가 (Short-circuit)

// && 연산자
if (ptr != nullptr && *ptr == 10) {
    // ptr이 nullptr이면 *ptr 평가 안함
}

// || 연산자
if (x == 0 || y / x > 10) {
    // x가 0이면 y / x 평가 안함 (0으로 나누기 방지)
}

FAQ

Q1: 우선순위를 외워야 하나요?

A: 기본적인 것만 외우고 복잡하면 괄호 사용.

Q2: 가장 헷갈리는 연산자는?

A:

• 비트 연산 vs 논리 연산
• 대입 vs 비교
• 증감 연산자

Q3: 괄호를 많이 쓰면 느려지나요?

A: 아니요. 컴파일러가 최적화합니다.

Q4: 정의되지 않은 동작은?

A: 같은 변수를 여러 번 수정하는 경우 (예: arr[i++] = i).

Q5: 단축 평가는?

A: &&와 ||는 왼쪽부터 평가하고 결과가 확정되면 중단.

Q6: 연산자 우선순위 학습 리소스는?

A:

• cppreference.com
• “C++ Primer”
• “Effective C++“

---

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ 연산자 오버로딩 | ”+, -, *, <<” 재정의 가이드
• C++ ADL | “Argument Dependent Lookup” 가이드
• C++ User-Defined Literals | “사용자 정의 리터럴” 가이드

관련 글

• C++ 연산자 오버로딩 |
• C++ ADL |
• C++ 함수 객체 |
• C++ User-Defined Literals |
• 배열과 리스트 | 코딩 테스트 필수 자료구조 완벽 정리