static_cast와 reinterpret_cast는 C++ 캐스트 연산자 가운데 컴파일러가 규칙을 아는 변환과 저수준 포인터·비트 재해석을 각각 담당하는 두 축입니다. C++는 값 변환이나 상속 계층 변환(static_cast), 포인터 재해석(reinterpret_cast), 실행 시간 다형성 확인(dynamic_cast), const 한정자 제거(const_cast)를 별도의 이름 있는 캐스트로 분리하여 코드만 봐도 변환 의도가 드러나도록 설계했습니다. 이 글에서는 2026-10-28(KST)에 g++ (Debian 14.2.0-19) 14.2.0(x86_64) 환경에서 확인한 실제 코드와 컴파일러 출력을 바탕으로 각 캐스트를 언제 쓰고 어떤 변환이 금지되는지 정리합니다.
핵심 요약
static_cast는 컴파일러가 의미를 아는 변환(숫자 타입 변환, 범위 지정 열거형 enum class와 정수 변환, void*를 원래 객체 포인터로 되돌리기, 상속 관계 포인터·참조 변환)에 쓰고, reinterpret_cast는 비트는 그대로 두고 다른 타입으로 보겠다는 저수준 변환(포인터와 std::uintptr_t 간 변환, 관련 없는 포인터 타입 간 변환)에 씁니다. static_cast는 int*를 double*로 바꾸지 못하고, reinterpret_cast는 double 값을 int로 바꾸지 못하며 const도 제거하지 못합니다. 실행 중 실제 타입 확인이 필요하면 dynamic_cast를 쓰고, const 제거는 const_cast를 씁니다.

static_cast와 reinterpret_cast 중 static_cast는 언제 씁니까?
한 줄 답: static_cast는 숫자 값 변환, enum class와 정수 변환, void*를 원래 객체 포인터 타입으로 복원, 상속 계층 내 포인터·참조 변환처럼 컴파일러가 변환 규칙을 이해하는 경우에 씁니다.
cppreference의 static_cast 문서에 따르면, static_cast는 부동소수점과 정수 사이의 값 변환, 범위 지정 열거형(enum class)과 정수 사이의 변환, void*를 원래 가리키던 객체 포인터 타입으로 되돌리는 변환, 상속 계층 안에서 기반 클래스(Base)와 파생 클래스(Derived)의 포인터 또는 참조를 바꾸는 변환을 수행합니다.
다만 상속 계층에서 기반 클래스 포인터를 파생 클래스 포인터로 내리는 다운캐스트(downcast)를 static_cast로 수행할 때는 실행 시간(runtime) 타입 확인을 하지 않습니다. 만약 대상 객체가 실제로 파생 클래스가 아니라면 미정의 동작(undefined behavior)이 발생합니다. 반면 다형성 타입(가상 함수가 있는 클래스)에 대해 dynamic_cast를 쓰면 실행 시간에 실제 타입을 확인하고, 포인터 변환에 실패할 경우 nullptr를 반환합니다. 다형성 기반 클래스에 가상 소멸자(virtual ~Base() = default;)를 두는 이유는 C++ 가상 소멸자란? 부모 포인터로 delete할 때 virtual이 필요한 이유 글에서 확인할 수 있습니다.
다음은 static_cast, dynamic_cast, reinterpret_cast의 동작을 함께 확인하는 casts_ok.cpp입니다.
#include <cstdint>
#include <cstdio>
struct Base { virtual ~Base() = default; };
struct Derived : Base { int v = 7; };
int main() {
// static_cast: 값 변환 (double -> int, 소수점 버림)
double d = 3.99;
int i = static_cast<int>(d);
std::printf("static_cast<int>(3.99) = %d\n", i);
// static_cast: enum class -> int
enum class Color { Red = 1, Green = 2 };
std::printf("static_cast<int>(Color::Green) = %d\n", static_cast<int>(Color::Green));
// static_cast: void* -> 원래 타입 포인터로 되돌리기
int n = 10;
void* vp = &n;
int* ip = static_cast<int*>(vp);
std::printf("static_cast<int*>(void*) -> *ip = %d\n", *ip);
// static_cast: 업캐스트/다운캐스트 (다운캐스트는 실제 타입을 확인하지 않음)
Derived der;
Base* bp = &der; // 업캐스트는 암시적
Derived* dp = static_cast<Derived*>(bp); // 실제 Derived라서 OK
std::printf("static_cast<Derived*>(Base*) -> v = %d\n", dp->v);
Base plain;
Derived* bad = dynamic_cast<Derived*>(&plain); // 실제 타입 확인 -> nullptr
std::printf("dynamic_cast on real Base -> %s\n", bad ? "non-null" : "nullptr");
// reinterpret_cast: 포인터 <-> 정수 (주소 값을 정수로)
std::uintptr_t addr = reinterpret_cast<std::uintptr_t>(&n);
int* back = reinterpret_cast<int*>(addr);
std::printf("reinterpret_cast round trip same pointer: %s, *back = %d\n",
back == &n ? "true" : "false", *back);
}
이 코드를 $ g++ -std=c++17 -Wall -Wextra casts_ok.cpp -o casts_ok 명령으로 컴파일하면 종료 코드 0(build exit=0)으로 빌드되면서 경고 1개가 출력됩니다.
casts_ok.cpp: In function ‘int main()’:
casts_ok.cpp:29:20: warning: ‘dynamic_cast<struct Derived*>(Base plain)’ can never succeed
29 | Derived* bad = dynamic_cast<Derived*>(&plain); // 실제 타입 확인 -> nullptr
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
컴파일러가 plain 객체가 파생 클래스가 아닌 실제 Base 객체임을 코드에서 바로 알 수 있어 이 dynamic_cast가 절대 성공할 수 없다고 알려 주는 경고입니다. 이어서 $ ./casts_ok를 실행한 결과는 다음과 같습니다.
static_cast<int>(3.99) = 3
static_cast<int>(Color::Green) = 2
static_cast<int*>(void*) -> *ip = 10
static_cast<Derived*>(Base*) -> v = 7
dynamic_cast on real Base -> nullptr
reinterpret_cast round trip same pointer: true, *back = 10
앞의 다섯 줄에서 double의 소수점 버림 변환(3), enum class의 정수 변환(2), void*에서 int*로의 복원(10), 실제 Derived 객체를 가리키는 Base*의 다운캐스트(7), 실제 Base 객체에 대한 dynamic_cast 실패 시 nullptr 반환을 확인할 수 있습니다.
reinterpret_cast는 언제 씁니까?
한 줄 답: reinterpret_cast는 포인터 주소를 그 크기를 담을 수 있는 정수(std::uintptr_t)로 바꾸거나 다시 원래 포인터로 되돌릴 때, 또는 서로 관련 없는 포인터 타입으로 해석 방식을 바꿀 때 씁니다.
cppreference의 reinterpret_cast 문서에 따르면, reinterpret_cast는 비트 패턴을 재해석하거나 포인터를 바라보는 타입을 바꿉니다. 포인터를 충분한 크기의 정수 타입(std::uintptr_t)으로 변환했다가 다시 원래의 포인터 타입으로 되돌리면 원래 포인터 값과 동일한 값을 얻는 것이 보장됩니다. 위 casts_ok 실행 결과의 마지막 줄(reinterpret_cast round trip same pointer: true, *back = 10)이 이 왕복 변환을 보여 줍니다.
임베디드 프로그래밍에서 고정된 하드웨어 레지스터 주소를 포인터로 변환할 때도 reinterpret_cast를 쓰는 것이 대표적인 용도입니다.
메모리에 저장된 바이트 순서(빅엔디안·리틀엔디안) 개념 자체에 관한 설명은 엔디안(Endianness)이란? 글을 참고할 수 있습니다.
서로 못 하는 변환은 무엇입니까?
한 줄 답: static_cast는 서로 관련 없는 포인터 타입(int*에서 double* 등)을 변환하지 못하고, reinterpret_cast는 숫자 값 변환(double에서 int 등)이나 const 한정자 제거를 하지 못합니다.
두 캐스트가 각각 허용하지 않는 변환을 세 개의 파일로 나누어 g++ -std=c++17 -Wall -Wextra -c 명령으로 컴파일하면 모두 종료 코드 1(exit=1)로 실패합니다.
첫째, casts_err1.cpp에서 int n = 1;의 주소를 static_cast<double*>(&n)으로 바꾸려 한 경우입니다($ g++ -std=c++17 -Wall -Wextra -c casts_err1.cpp).
casts_err1.cpp: In function ‘int main()’:
casts_err1.cpp:3:17: error: invalid ‘static_cast’ from type ‘int*’ to type ‘double*’
3 | double* p = static_cast<double*>(&n); // 관련 없는 포인터 타입끼리: static_cast 불가
| ^~~~~~~~~~~~~~~~~~~~~~~~
둘째, casts_err2.cpp에서 double d = 3.5; 값을 reinterpret_cast<int>(d)로 변환하려 한 경우입니다($ g++ -std=c++17 -Wall -Wextra -c casts_err2.cpp).
casts_err2.cpp: In function ‘int main()’:
casts_err2.cpp:3:13: error: invalid cast from type ‘double’ to type ‘int’
3 | int i = reinterpret_cast<int>(d); // 값 변환은 reinterpret_cast로 못 함
| ^~~~~~~~~~~~~~~~~~~~~~~~
셋째, casts_err3.cpp에서 const int c = 5;의 포인터를 reinterpret_cast<int*>(&c)로 변환해 const를 떼어 내려 한 경우입니다($ g++ -std=c++17 -Wall -Wextra -c casts_err3.cpp).
casts_err3.cpp: In function ‘int main()’:
casts_err3.cpp:3:14: error: ‘reinterpret_cast’ from type ‘const int*’ to type ‘int*’ casts away qualifiers
3 | int* p = reinterpret_cast<int*>(&c); // const 제거는 const_cast만 가능
| ^~~~~~~~~~~~~~~~~~~~~~~~~~
cppreference의 캐스트 규칙과 위 실측 결과를 바탕으로 변환 종류별 가능 여부를 표로 정리하면 다음과 같습니다.
| 변환 종류 | static_cast | reinterpret_cast | const_cast | dynamic_cast |
|---|---|---|---|---|
숫자 값 변환 (double → int) | 가능 | 불가 | 불가 | 불가 |
enum class ↔ 정수 (int) | 가능 | 불가 | 불가 | 불가 |
void* → 원래 객체 포인터 (T*) | 가능 | 가능 | 불가 | 불가 |
상속 관계 포인터 (Base* ↔ Derived*) | 가능 (실행 중 확인 없음) | 가능 (권장 안 함) | 불가 | 실행 중 확인 (다형성 타입) |
관련 없는 포인터 타입 (int* → double*) | 불가 | 가능 | 불가 | 불가 |
포인터 ↔ 정수 (std::uintptr_t) | 불가 | 가능 | 불가 | 불가 |
const 한정자 제거 | 불가 | 불가 | 가능 | 불가 |

C 스타일 캐스트 (T)x는 왜 피합니까?
한 줄 답: C 스타일 캐스트 (T)x는 컴파일러가 const_cast, static_cast, reinterpret_cast와 그 조합을 순서대로 시도해 첫 번째로 성공하는 변환을 적용하므로, 코드만 봐서는 어떤 변환이 일어났는지 알 수 없기 때문입니다.
cppreference의 명시적 형변환(explicit type conversion) 문서에 따르면, (T)x 또는 함수형 표기 T(x)로 작성한 C 스타일 캐스트는 다음 순서대로 C++ 이름 있는 캐스트를 시도해 첫 번째로 문법 규칙을 만족하는 변환을 선택합니다.
const_cast<T>(x)static_cast<T>(x)static_cast<T>(x)뒤에const_cast를 이어서 적용reinterpret_cast<T>(x)reinterpret_cast<T>(x)뒤에const_cast를 이어서 적용
이 때문에 원래는 안전한 값 변환이나 상속 계층 변환을 의도했더라도, 포인터 타입이 바뀌었을 때 컴파일 에러 대신 조용히 reinterpret_cast로 바뀌거나 const 한정자가 함께 제거될 수 있습니다. 한편 클래스 생성자를 통한 의도하지 않은 암시적 변환을 막는 방법은 C++ explicit이란? 생성자 암시적 변환을 막아야 할 때 글에서 다룹니다.
자주 묻는 질문은 무엇입니까?
한 줄 답: reinterpret_cast로 바꾼 포인터의 역참조와 타입 별칭 규칙, 값 비트를 복사하는 C++20 std::bit_cast, 암시적 정수 승격과의 관계를 정리합니다.
reinterpret_cast로 바꾼 포인터를 역참조해도 됩니까?
reinterpret_cast로 얻은 관련 없는 다른 타입의 포인터를 통해 객체에 접근(역참조)하면 타입 별칭(type-aliasing, strict aliasing) 규칙을 위반하여 미정의 동작(undefined behavior)이 발생할 수 있으므로 주의해야 합니다.
std::bit_cast는 무엇입니까?
C++20의 <bit> 헤더에 도입된 std::bit_cast는 객체의 비트 표현을 크기가 같은 다른 타입의 값으로 복사하는 함수로, 값의 비트를 재해석할 때 표준에서 정의된 안전한 방법을 제공합니다.
정수 승격과는 어떤 관계입니까?
bool, char, short 같은 작은 정수 타입이 연산식에서 자동으로 int 등으로 변환되는 암시적 정수 승격 규칙은 C++ 정수 승격(integral promotion)이란? ~true가 true가 되는 이유 글에서 확인할 수 있습니다.
함께 보면 좋은 글은 무엇입니까?
한 줄 답: C++ 정수 승격, 생성자 암시적 변환 방지, 가상 소멸자, 엔디안과 메모리 세그먼트를 다룬 관련 글입니다.
- C++ 정수 승격(integral promotion)이란? ~true가 true가 되는 이유
- 엔디안(Endianness)이란?
- C++ 가상 소멸자란? 부모 포인터로 delete할 때 virtual이 필요한 이유
- C++ explicit이란? 생성자 암시적 변환을 막아야 할 때
- .data와 .bss 차이
출처는 어디입니까?
한 줄 답: cppreference의 static_cast, reinterpret_cast, 명시적 형변환 문서와 직접 실행한 GCC 결과입니다.
- cppreference — static_cast conversion (확인 2026-10-28)
- cppreference — reinterpret_cast conversion (확인 2026-10-28)
- cppreference — Explicit type conversion (확인 2026-10-28)
- 직접 실행 환경:
g++ (Debian 14.2.0-19) 14.2.0, x86_64 (확인 2026-10-28 KST)