핵심 요약
산술 연산이나 비트 연산을 수행하기 전에 int보다 작은 정수 타입(bool, char, short 등)은 값을 완전히 보존하는 int (또는 unsigned int)로 자동 변환됩니다. 이를 **C++ 정수 승격(integral promotion)**이라고 부릅니다. true는 승격 시 int 1이 되고, 비트 반전(~)을 적용하면 2의 보수 표현에 따라 -2가 되며, 이를 다시 bool로 변환하면 0이 아니므로 true가 됩니다. 불리언을 반전할 때는 ~ 대신 !를 사용해야 합니다.
bool 값을 반전하려고 ~ 연산자를 사용했다가 결과가 계속 true로 나와 당황한 적이 있으실 겁니다. C++ 개발 중 흔히 겪는 실수입니다. 이번 글에서는 C++ 정수 승격의 동작 원리와 ~true가 왜 다시 true가 되는지, 그리고 enum과 비트마스크에서 이 규칙을 안전하게 다루는 방법을 실제 컴파일 결과와 함께 정리합니다.
C++ 정수 승격이란? bool·char·short는 왜 int로 바뀌나요?
한 줄 답: C++ 정수 승격(integral promotion)은 산술 및 비트 연산을 수행하기 전에 int보다 작은 정수 타입이 값을 완전히 보존하는 int (또는 unsigned int)로 자동 변환되는 표준 규칙입니다.

-
C++ 정수 승격이 일어나는 근본적인 이유는 다음과 같습니다. C++의 산술 연산자(
+,-,*등)와 비트 연산자(~,|,&등)는int보다 작은 정수 타입을 피연산자로 직접 받지 않습니다. 이에 따라 연산을 수행하기 직전char,signed char,unsigned char,short,unsigned short,bool, 그리고 고정 underlying 타입이 없는 unscoped enum의 prvalue가 더 큰 정수 타입으로 자동 승격됩니다. 원래 타입의 모든 값을int가 표현할 수 있다면int로, 그렇지 않다면unsigned int로 승격되며 값은 항상 완전히 보존됩니다 (cppreference Implicit conversions). -
오버로드 해결(overload resolution)에서도 승격은 우선순위가 높습니다.
char -> int승격은char -> short같은 표준 변환(standard conversion)보다 우선합니다. 컴파일러가 실제로 어떻게 승격하는지 확인하려면 C++ Insights에서 중간 변환 결과를 직접 살펴볼 수 있습니다. -
작은 정수 타입의 산술 연산과
std::uint8_t비트 연산이 실제로int로 승격되는지 코드로 살펴보겠습니다.a + b(char + char),s + s(short + short),t + t(bool + bool),~u(~std::uint8_t)의 결과 타입이 모두int임을 컴파일 시점에static_assert와std::is_same_v로 검증합니다. 이때 테스트 환경에서std::uint8_t는unsigned char의 별칭(구현 정의, implementation-defined)이며,char의 부호 여부(signedness) 역시 플랫폼 및 컴파일러 구현에 따라 달라집니다.
// char·short·bool 연산 결과가 int가 되는지 컴파일 시점에 확인합니다
#include <cstdint>
#include <iostream>
#include <type_traits>
int main() {
char a = 100, b = 100;
short s = 1;
bool t = true;
std::uint8_t u = 0x0F;
auto c = a + b; // char + char
static_assert(std::is_same_v<decltype(c), int>);
static_assert(std::is_same_v<decltype(s + s), int>);
static_assert(std::is_same_v<decltype(t + t), int>);
static_assert(std::is_same_v<decltype(~u), int>); // uint8_t도 int로
std::cout << "a + b = " << c << '\n';
std::cout << "true + true = " << (t + t) << '\n';
std::cout << "~u = " << ~u << '\n';
}
컴파일러 진단 (g++ 14.2.0 x86_64, -std=c++20 -Wall -Wextra): 경고 없이 성공적으로 컴파일됩니다.
실행 결과:
a + b = 200
true + true = 2
~u = -16
- 부호가 다른 정수를 비교할 때도 승격 규칙이 결과를 좌우합니다.
int i = -1;과unsigned char uc = 1;을 비교하면(i < uc),unsigned char는int보다 랭크가 낮고int가 모든 값을 표현할 수 있어int(1)로 승격됩니다. 그 결과-1 < 1이 되어true가 나옵니다. 반면int i = -1;과unsigned int ui = 1;을 비교하면(i < ui),unsigned int는 승격 대상이 아니므로 통상 산술 변환(usual arithmetic conversions)에 따라 부호 있는i가unsigned int로 변환됩니다. 부호 없는 변환은 모듈러 규칙을 따르므로-1은unsigned int의 최댓값이 되고, 그래서 비교 결과는false입니다. 이는 정의되지 않은 동작(UB)이 아닌 C++ 표준의 잘 정의된 부호 없는 변환(well-defined unsigned conversion)이지만, 직관과 달라 실수를 유발하므로-Wsign-compare경고를 주의 깊게 살펴야 합니다.
// 작은 unsigned는 int로 승격되지만, unsigned int는 승격되지 않습니다
#include <iostream>
int main() {
int i = -1;
unsigned char uc = 1; // int로 승격 -> -1 < 1 은 참
unsigned int ui = 1; // i가 unsigned int로 변환 -> 큰 값과 비교
std::cout << std::boolalpha;
std::cout << "-1 < (unsigned char)1 : " << (i < uc) << '\n';
std::cout << "-1 < (unsigned int)1 : " << (i < ui) << '\n';
}
컴파일러 진단 (g++ 14.2.0 x86_64, -std=c++20 -Wall -Wextra):
p4_sign_compare.cpp: In function ‘int main()’:
p4_sign_compare.cpp:11:51: warning: comparison of integer expressions of different signedness: ‘int’ and ‘unsigned int’ [-Wsign-compare]
11 | std::cout << "-1 < (unsigned int)1 : " << (i < ui) << '\n';
| ~~^~~~
실행 결과:
-1 < (unsigned char)1 : true
-1 < (unsigned int)1 : false
~true는 왜 다시 true가 되나요?
한 줄 답: true가 int 1로 승격된 뒤 비트 반전되어 음수 -2가 되고, 이를 다시 bool로 변환할 때 0이 아니므로 true로 평가되기 때문입니다.

-
~true가true로 평가되는 과정은 다음 네 단계로 일어납니다.- 정수 승격:
bool타입true가 비트 연산자~를 만나int 1로 승격됩니다(false는 0, true는 1로 승격). - 비트 반전:
int 1에 비트 NOT 연산(~1)이 수행됩니다. C++20부터 부호 있는 정수의 음수 표현이 2의 보수(two’s complement)로만 보장되므로 (cppreference Fundamental types), 비트가 반전된 결과는 정확히-2가 됩니다. - 불리언 변환: 연산 결과인
int -2가 다시bool로 변환됩니다. 0은false, 0이 아닌 모든 값은true로 변환되므로-2는true가 됩니다. - 최종 결과: 따라서
static_cast<bool>(~true) == true가 성립합니다 (Hacker News 토론 미러).
- 정수 승격:
-
false에 비트 반전(~false)을 적용해도 같은 원리로true가 됩니다.false는int 0으로 승격되고,~0은 2의 보수에서-1이 되며,-1역시 0이 아니므로bool변환 시true가 됩니다. 즉 비트 연산자~를 쓰면true와false모두true로 귀결되는 논리 오류가 발생합니다. -
불리언 값을 반전할 때는 비트 반전 연산자(
~) 대신 반드시 논리 부정 연산자(!)를 사용해야 합니다. 이 글의 g++ 14.2.0에서는-Wall을 켜면bool표현식에~를 쓸 때-Wbool-operation경고와 함께did you mean to use logical not (‘!’)?라는 안내 메시지가 출력됩니다.
// ~true가 왜 true인지 단계별로 출력합니다
#include <iostream>
bool Complement(bool x) {
return ~x; // 의도는 반전이지만 실제로는 int 비트 반전
}
int main() {
bool t = true;
int promoted = t; // 승격: true -> 1
int flipped = ~t; // ~1 -> -2 (C++20부터 2의 보수 보장)
bool back = flipped; // 0이 아니므로 true
std::cout << std::boolalpha;
std::cout << "promoted = " << promoted << '\n';
std::cout << "~true = " << flipped << '\n';
std::cout << "bool(~true) = " << back << '\n';
std::cout << "Complement(true) = " << Complement(true) << '\n';
std::cout << "Complement(false) = " << Complement(false) << '\n';
std::cout << "!true = " << !t << '\n';
}
컴파일러 진단 (g++ 14.2.0 x86_64, -std=c++20 -Wall -Wextra):
p2_not_true.cpp: In function ‘bool Complement(bool)’:
p2_not_true.cpp:5:13: warning: ‘~’ on an expression of type ‘bool’ [-Wbool-operation]
5 | return ~x; // 의도는 반전이지만 실제로는 int 비트 반전
| ^
p2_not_true.cpp:5:13: note: did you mean to use logical not (‘!’)?
p2_not_true.cpp: In function ‘int main()’:
p2_not_true.cpp:11:20: warning: ‘~’ on an expression of type ‘bool’ [-Wbool-operation]
11 | int flipped = ~t; // ~1 -> -2 (C++20부터 2의 보수 보장)
| ^
p2_not_true.cpp:11:20: note: did you mean to use logical not (‘!’)?
실행 결과:
promoted = 1
~true = -2
bool(~true) = true
Complement(true) = true
Complement(false) = true
!true = false
enum·비트마스크에서 실수를 막는 법은?
한 줄 답: enum class에 고정 underlying 타입을 명시하고 비트 연산자를 오버로딩하여 의도치 않은 int 승격과 정의되지 않은 동작(UB)을 차단해야 합니다.
-
고정 underlying 타입이 없는 unscoped enum(
enum Color { Red = 1, Green = 2 };)은 비트 연산(Red | Green) 시 값 범위를 담을 수 있는 첫 번째 정수 타입인int로 자동 승격되어 계산됩니다. 이때 계산된int값을 다시 해당 enum 타입으로static_cast할 때 값이 열거형의 유효 범위를 벗어나면 C++ 표준상 정의되지 않은 동작(UB)이 발생합니다 (cppreference static_cast). -
고정 underlying 타입을 지정한
enum class를 사용하면 이 위험을 방지할 수 있습니다.enum class Perm : std::uint8_t { Read = 1, Write = 2, Exec = 4 };처럼 underlying 타입을 명시하면, 정수에서 해당 열거형으로static_cast할 때 underlying 타입으로 먼저 변환되므로 값 범위를 벗어나더라도 UB가 발생하지 않습니다(CWG 2338).std::underlying_type_t를 활용해operator|와 포함 여부를 검사하는has헬퍼 함수를 오버로딩하면 타입 안전한 비트 플래그를 구축할 수 있습니다. C++23부터는<utility>의std::to_underlying으로 열거형 값을 기반 정수 타입으로 간결하게 추출할 수 있습니다. 참고로 GCC가bool기반 enum에 대해 절삭(truncation) 등 특이 동작을 보인다는 논의도 있으나, 이는 컴파일러별 동작이므로 일반화하여 단정하지 않고 링크로만 남겨둡니다 (Hacker News 토론 미러).
// enum class + 고정 underlying 타입으로 비트마스크를 안전하게 다룹니다
#include <cstdint>
#include <iostream>
#include <type_traits>
enum class Perm : std::uint8_t { Read = 1, Write = 2, Exec = 4 };
constexpr Perm operator|(Perm a, Perm b) {
using U = std::underlying_type_t<Perm>;
return static_cast<Perm>(static_cast<U>(a) | static_cast<U>(b));
}
constexpr bool has(Perm set, Perm p) {
using U = std::underlying_type_t<Perm>;
return (static_cast<U>(set) & static_cast<U>(p)) != 0;
}
enum Color { Red = 1, Green = 2 }; // unscoped, underlying 고정 없음
int main() {
Perm rw = Perm::Read | Perm::Write;
std::cout << std::boolalpha;
std::cout << "rw has Write: " << has(rw, Perm::Write) << '\n';
std::cout << "rw has Exec: " << has(rw, Perm::Exec) << '\n';
auto x = Red | Green; // unscoped enum은 승격되어 int 연산
static_assert(std::is_same_v<decltype(x), int>);
std::cout << "Red | Green = " << x << " (int)\n";
}
컴파일러 진단 (g++ 14.2.0 x86_64, -std=c++20 -Wall -Wextra): 경고 없이 성공적으로 컴파일됩니다.
실행 결과:
rw has Write: true
rw has Exec: false
Red | Green = 3 (int)
-
정수 승격 버그를 방지하는 실무 체크리스트입니다.
- 불리언 논리 반전:
bool값의 반전에는 비트 반전 연산자(~) 대신 반드시 논리 부정 연산자(!)를 사용합니다. - 비트마스크 정의: 열거형으로 비트 플래그를 정의할 때는 unscoped enum 대신
enum class와 고정 underlying 타입(std::uint8_t등)을 명시하고 필요한 비트 연산자를 오버로딩합니다. - 부호 비교 주의:
unsigned char등 작은 unsigned 타입은int로 승격되지만unsigned int는 승격되지 않으므로, 서로 다른 부호 간 비교 시 암시적 변환 규칙을 염두에 둡니다. - 컴파일러 경고 강제: 빌드 시
-Wall -Wextra를 항상 활성화해-Wbool-operation및-Wsign-compare경고를 즉시 확인합니다.
- 불리언 논리 반전:
-
정수 승격은 표준이 정한 자동 변환 규칙이라 코드에 드러나지 않습니다. 그래서 bool 반전, 부호가 다른 비교, enum 비트 연산처럼 결과가 직관과 다를 수 있는 곳에서는 규칙을 알고, 경고를 켜 두는 습관이 중요합니다.
[시험용/면접 핵심 한 줄] C++ 산술·비트 연산자는 int보다 작은 정수 타입을 직접 받지 않아 int로 자동 승격하므로, ~true는 ~int(1) == -2를 거쳐 0이 아닌 값이 되어 다시 true로 평가되며, 논리 부정에는 반드시 !x를 사용해야 합니다.
면접 답변 템플릿: “C++에서는 산술 및 비트 연산 수행 전 char, short, bool과 같은 작은 정수 타입이 값을 완전히 보존하는 int(또는 unsigned int)로 자동 변환되는 ‘C++ 정수 승격’이 일어납니다. 이에 따라 true를 계산할 때 true는 int 1로 승격된 후 비트 반전되어 -2(C++20 이후 2의 보수 기준)가 되며, 이를 다시 bool로 변환하면 0이 아니므로 true가 반환됩니다. 따라서 불리언 값의 반전에는 비트 NOT() 대신 논리 NOT(!)을 사용해야 하며, 비트마스크 작성 시에는 enum class와 고정 underlying 타입을 지정해 의도치 않은 승격 부작용을 방지해야 합니다.”
이해했는지 Q&A로 확인해 볼까요?
Q1. C++에서 정수 승격(Integral Promotion)이란 무엇이며 왜 발생하나요?
A1. 산술 연산자나 비트 연산자가 int보다 작은 정수 타입을 피연산자로 직접 지원하지 않기 때문에, 연산 수행 직전에 bool, char, short 등의 작은 정수 타입이나 고정 underlying이 없는 unscoped enum을 값을 온전히 보존할 수 있는 int(또는 unsigned int)로 자동 변환하는 C++ 표준 규칙입니다.
Q2. static_cast<bool>(~true)를 실행했을 때 결과가 왜 다시 true가 되나요?
A2. true가 정수 승격에 의해 int 1로 변환된 후 비트 반전(~)되어 -2(C++20 표준에 의해 2의 보수 보장)가 되고, 이 -2가 불리언 변환 규칙에 따라 0이 아닌 값(nonzero)으로서 최종적으로 true로 평가되기 때문입니다.
Q3. int i = -1; unsigned char uc = 1; unsigned int ui = 1;일 때, i < uc는 참이고 i < ui는 거짓인 이유는 무엇인가요?
A3. unsigned char는 int보다 랭크가 낮아 int가 모든 값을 담을 수 있으므로 int(1)로 승격되어 -1 < 1이 되어 참이 됩니다. 반면 unsigned int는 승격 대상이 아니므로 통상 산술 변환에 의해 int -1이 unsigned int의 최댓값으로 변환되어 비교되므로 거짓이 됩니다.
Q4. 비트마스크를 구현할 때 일반 unscoped enum 대신 enum class와 고정 underlying 타입을 사용하는 이유는 무엇인가요?
A4. 일반 unscoped enum은 연산 시 int로 승격되어 의도치 않은 타입 혼용이 생기고, 연산 결과를 다시 enum으로 캐스팅할 때 값 범위를 벗어나면 정의되지 않은 동작(UB)이 발생할 수 있습니다. 반면 고정 underlying 타입을 명시한 enum class는 underlying 타입으로 먼저 변환되므로 UB가 없고(CWG 2338) 강력한 타입 안전성을 보장하기 때문입니다.