C++ 캐스팅 | "static_cast/dynamic_cast" 4가지 완벽 정리

1. static_cast

용도: 컴파일 타임에 타입 변환

// 기본 타입 변환
int x = 10;
double y = static_cast<double>(x);

// 포인터 업캐스팅 (안전)
class Base {};
class Derived : public Base {};

Derived* d = new Derived();
Base* b = static_cast<Base*>(d);  // OK

// 포인터 다운캐스팅 (위험)
Base* b2 = new Base();
Derived* d2 = static_cast<Derived*>(b2);  // 컴파일은 되지만 위험!

언제 사용:

• 기본 타입 변환
• 명시적 타입 변환
• 업캐스팅

2. dynamic_cast

용도: 런타임에 안전한 다운캐스팅

class Base {
public:
    virtual ~Base() {}  // 가상 함수 필요!
};

class Derived : public Base {
public:
    void derivedMethod() {
        cout << "Derived 메서드" << endl;
    }
};

int main() {
    Base* b = new Derived();
    
    // 안전한 다운캐스팅
    Derived* d = dynamic_cast<Derived*>(b);
    if (d) {
        d->derivedMethod();  // 성공
    } else {
        cout << "캐스팅 실패" << endl;
    }
    
    // 실패 예시
    Base* b2 = new Base();
    Derived* d2 = dynamic_cast<Derived*>(b2);
    if (!d2) {
        cout << "캐스팅 실패" << endl;  // 출력됨
    }
}

언제 사용:

• 다운캐스팅
• 타입 확인이 필요할 때
• RTTI(Run-Time Type Information) 필요 시

3. const_cast

용도: const 속성 제거/추가

void legacyFunction(char* str) {
    // const 없는 레거시 함수
}

void modernFunction(const char* str) {
    // const 제거 (위험!)
    legacyFunction(const_cast<char*>(str));
}

// const 추가
int main() {
    int x = 10;
    const int* ptr = const_cast<const int*>(&x);
}

주의: 원래 const인 객체를 수정하면 정의되지 않은 동작!

4. reinterpret_cast

용도: 포인터를 다른 타입으로 재해석

int x = 42;
int* ptr = &x;

// 포인터를 정수로
uintptr_t addr = reinterpret_cast<uintptr_t>(ptr);
cout << "주소: " << addr << endl;

// 정수를 포인터로
int* ptr2 = reinterpret_cast<int*>(addr);

// 포인터 타입 변환 (위험!)
double* dptr = reinterpret_cast<double*>(ptr);

언제 사용:

• 저수준 프로그래밍
• 하드웨어 접근
• 직렬화/역직렬화

C 스타일 캐스트 vs C++ 캐스트

// ❌ C 스타일 (위험)
int x = 10;
double y = (double)x;

Base* b = new Derived();
Derived* d = (Derived*)b;  // 어떤 캐스트인지 불명확

// ✅ C++ 스타일 (명확)
double y2 = static_cast<double>(x);
Derived* d2 = dynamic_cast<Derived*>(b);

실전 예시

예시 1: 다형성과 dynamic_cast

class Shape {
public:
    virtual void draw() = 0;
    virtual ~Shape() {}
};

class Circle : public Shape {
public:
    void draw() override { cout << "원" << endl; }
    double getRadius() { return 5.0; }
};

class Rectangle : public Shape {
public:
    void draw() override { cout << "사각형" << endl; }
    double getWidth() { return 10.0; }
};

void processShape(Shape* shape) {
    shape->draw();
    
    // Circle인지 확인
    if (Circle* circle = dynamic_cast<Circle*>(shape)) {
        cout << "반지름: " << circle->getRadius() << endl;
    }
    
    // Rectangle인지 확인
    if (Rectangle* rect = dynamic_cast<Rectangle*>(shape)) {
        cout << "너비: " << rect->getWidth() << endl;
    }
}

int main() {
    Shape* shapes[] = {
        new Circle(),
        new Rectangle()
    };
    
    for (Shape* shape : shapes) {
        processShape(shape);
        delete shape;
    }
}

예시 2: 직렬화

#include <cstring>

struct Data {
    int id;
    double value;
};

void serialize(const Data& data, char* buffer) {
    // 구조체를 바이트 배열로
    memcpy(buffer, &data, sizeof(Data));
}

Data deserialize(const char* buffer) {
    Data data;
    memcpy(&data, buffer, sizeof(Data));
    return data;
}

int main() {
    Data original = {42, 3.14};
    char buffer[sizeof(Data)];
    
    serialize(original, buffer);
    Data restored = deserialize(buffer);
    
    cout << restored.id << ", " << restored.value << endl;
}

예시 3: 플러그인 시스템

class Plugin {
public:
    virtual void execute() = 0;
    virtual ~Plugin() {}
};

class AudioPlugin : public Plugin {
public:
    void execute() override { cout << "오디오 처리" << endl; }
    void setVolume(int v) { volume = v; }
private:
    int volume = 100;
};

void configurePlugin(Plugin* plugin) {
    // AudioPlugin인지 확인하고 볼륨 설정
    if (AudioPlugin* audio = dynamic_cast<AudioPlugin*>(plugin)) {
        audio->setVolume(80);
    }
}

자주 발생하는 문제

문제 1: dynamic_cast 실패 무시

// ❌ 위험
Base* b = new Base();
Derived* d = dynamic_cast<Derived*>(b);
d->derivedMethod();  // 크래시! (d는 nullptr)

// ✅ 체크
if (Derived* d = dynamic_cast<Derived*>(b)) {
    d->derivedMethod();
} else {
    cout << "캐스팅 실패" << endl;
}

문제 2: const_cast 남용

// ❌ 정의되지 않은 동작
const int x = 10;
int* ptr = const_cast<int*>(&x);
*ptr = 20;  // 위험!

// ✅ 원래 non-const인 경우만
int y = 10;
const int* cptr = &y;
int* ptr2 = const_cast<int*>(cptr);
*ptr2 = 20;  // OK

문제 3: reinterpret_cast 오용

// ❌ 정렬 문제
int x = 42;
double* dptr = reinterpret_cast<double*>(&x);
// *dptr;  // 크래시 가능!

// ✅ 같은 크기, 같은 정렬
uint32_t u = 42;
int32_t* iptr = reinterpret_cast<int32_t*>(&u);  // OK

캐스팅 선택 가이드

타입 변환이 필요한가?
├─ 기본 타입 변환? → static_cast
├─ 다운캐스팅?
│  ├─ 안전성 필요? → dynamic_cast
│  └─ 성능 중요? → static_cast (주의!)
├─ const 제거? → const_cast (주의!)
└─ 포인터 재해석? → reinterpret_cast (위험!)

성능 비교

// static_cast: 컴파일 타임, 오버헤드 없음
Derived* d1 = static_cast<Derived*>(base);

// dynamic_cast: 런타임 타입 체크, 약간 느림
Derived* d2 = dynamic_cast<Derived*>(base);

FAQ

Q1: 어떤 캐스트를 사용해야 하나요?

A:

1. 먼저 캐스트 없이 해결 시도
2. static_cast (가장 일반적)
3. dynamic_cast (다운캐스팅)
4. const_cast (레거시 코드)
5. reinterpret_cast (저수준)

Q2: C 스타일 캐스트는 왜 나쁜가요?

A:

• 어떤 캐스트인지 불명확
• 검색하기 어려움
• 의도하지 않은 변환 가능

Q3: dynamic_cast는 왜 느린가요?

A: RTTI를 사용하여 런타임에 타입을 확인하기 때문입니다.

Q4: 가상 함수 없이 dynamic_cast?

A: 불가능합니다. 가상 함수가 있어야 RTTI가 활성화됩니다.

Q5: 캐스팅을 피하려면?

A:

• 가상 함수 사용
• 템플릿 사용
• 좋은 설계

Q6: 캐스팅 디버깅은?

A:

• dynamic_cast 반환값 체크
• assert 사용
• 로깅 추가

---

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

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

• C++ 타입 변환 | “Type Conversion” 가이드
• C++ constexpr Lambda | “컴파일 타임 람다” 가이드
• C++ Extern Linkage | “외부 연결” 가이드

관련 글

• C++ 타입 변환 |
• 배열과 리스트 | 코딩 테스트 필수 자료구조 완벽 정리
• C++ Adapter Pattern 완벽 가이드 | 인터페이스 변환과 호환성
• C++ ADL |
• C++ Aggregate Initialization |