Embedded C++ for Real Systems · 26/41

No-RTTI C++ 설계 — dynamic_cast 제거와 정적 타입 분기

2026년 4월 30일 · Hawk · 4분 읽기

cpp embedded no-rtti variant type-id polymorphism

Twitter LinkedIn

#한 줄 요약

“RTTI 없이도 type-safe한 다형성이 가능합니다.” enum tag, std::variant, CRTP가 세 가지 대안입니다.

#어떤 문제를 푸는가

C++의 RTTI(Run-Time Type Information)는 세 가지 기능을 제공합니다.

typeid(obj)로 type 정보를 얻습니다.
dynamic_cast<T*>(p)로 안전한 down-cast를 수행합니다.
예외 처리에서 type-based catch를 가능하게 합니다.

비용은 다음과 같습니다.

type info 테이블이 클래스당 수십~수백 byte를 차지합니다.
vtable에 type info 포인터가 추가됩니다.
총량이 수 KB에 이를 수 있습니다.

임베디드는 -fno-rtti로 빌드합니다. 그렇다면 type 정보가 필요한 상황은 어떻게 처리할까요?

1
class Shape { /* virtual */ };
2
class Circle : public Shape {};
3

4
Shape* s = create();
5
auto* c = dynamic_cast<Circle*>(s);   // RTTI 필요
6
if (c) c->circle_method();

이 글은 RTTI 없는 세 가지 대안을 다룹니다.

#대안 1 — Enum Tag

가장 단순한 방식으로, type을 enum으로 표현합니다.

1
enum class ShapeType { Circle, Square, Triangle };
2

3
class Shape {
4
public:
5
    Shape(ShapeType t) : type_(t) {}
6
    ShapeType type() const { return type_; }
7
    virtual ~Shape() = default;
8

9
private:
10
    ShapeType type_;
11
};
12

13
class Circle : public Shape {
14
public:
15
    Circle() : Shape(ShapeType::Circle) {}
16
    void roll() { /* */ }
17
};
18

19
// 사용
20
Shape* s = create();
21
if (s->type() == ShapeType::Circle) {
22
    static_cast<Circle*>(s)->roll();
23
}

type_ enum이 type을 식별하는 역할을 합니다. static_cast는 안전 검증을 해 주지 않으므로 enum 체크와 짝지어 씁니다.

비용은 클래스당 enum size(4 byte) 정도로, RTTI보다 작습니다.

#헬퍼 매크로

1
template<typename Derived, typename Base>
2
Derived* checked_cast(Base* base) {
3
    if (base && base->type() == TypeOf<Derived>::value) {
4
        return static_cast<Derived*>(base);
5
    }
6
    return nullptr;
7
}
8

9
template<typename T> struct TypeOf;
10
template<> struct TypeOf<Circle> { static constexpr ShapeType value = ShapeType::Circle; };
11
template<> struct TypeOf<Square> { static constexpr ShapeType value = ShapeType::Square; };
12

13
auto* c = checked_cast<Circle>(s);

dynamic_cast를 흉내 낼 수 있지만, 모든 type을 enum과 TypeOf 매핑으로 등록해야 합니다.

#대안 2 — `std::variant` (C++17)

type-safe tagged union입니다. closed type set에 자연스럽게 들어맞습니다.

1
#include <variant>
2

3
class Circle {
4
public:
5
    void roll() { /* */ }
6
    float area() const { return 3.14f * r * r; }
7
private:
8
    float r = 1.0f;
9
};
10

11
class Square {
12
public:
13
    float area() const { return s * s; }
14
private:
15
    float s = 1.0f;
16
};
17

18
class Triangle {
19
public:
20
    float area() const { return 0.5f * b * h; }
21
private:
22
    float b = 1.0f, h = 1.0f;
23
};
24

25
using Shape = std::variant<Circle, Square, Triangle>;
26

27
Shape s = Circle{};
28

29
// 1. holds_alternative
30
if (std::holds_alternative<Circle>(s)) {
31
    std::get<Circle>(s).roll();
32
}
33

34
// 2. std::visit — 모든 가능 타입에 적용
35
float a = std::visit([](auto&& shape) {
36
    return shape.area();
37
}, s);
38

39
// 3. if constexpr 분기
40
std::visit([](auto&& shape) {
41
    using T = std::decay_t<decltype(shape)>;
42
    if constexpr (std::is_same_v<T, Circle>) {
43
        shape.roll();
44
    } else if constexpr (std::is_same_v<T, Square>) {
45
        // square 전용
46
    }
47
}, s);

std::variant의 내부 size는 max(sizeof of all types) + index이며 heap을 쓰지 않습니다.

#가상 함수의 완전 대체

1
// 전통 — virtual
2
class IShape {
3
public:
4
    virtual ~IShape() = default;
5
    virtual float area() const = 0;
6
};
7

8
// variant 대체 — vtable 없음, RTTI 없음
9
using Shape = std::variant<Circle, Square, Triangle>;
10

11
float compute_area(const Shape& s) {
12
    return std::visit([](auto&& sh) { return sh.area(); }, s);
13
}

컴파일 타임에 모든 type을 알고 있어야 하며, 런타임에 type을 추가할 수는 없습니다.

장점은 다음과 같습니다.

vtable과 type info가 모두 0입니다.
visitor가 인라인되어 간접 호출이 0입니다.
value semantics를 가집니다.

단점도 있습니다.

type set이 closed라서 런타임 확장이 불가합니다.
모든 type의 메모리를 차지하므로(가장 큰 type이 sizeof를 결정합니다) 큰 type 하나가 전체를 부풉니다.

자세한 비교는 Part 4-06: State Machine에서 다룹니다.

#대안 3 — CRTP (Static Polymorphism)

Part 2-08에서 다룬 패턴으로, 컴파일 타임에 type을 결정합니다.

1
template<typename Derived>
2
class ShapeBase {
3
public:
4
    float area() const {
5
        return static_cast<const Derived*>(this)->area_impl();
6
    }
7
};
8

9
class Circle : public ShapeBase<Circle> {
10
public:
11
    float area_impl() const { return 3.14f * r * r; }
12
private:
13
    float r;
14
};
15

16
Circle c;
17
float a = c.area();   // compile-time dispatch

RTTI와 vtable이 모두 0입니다. 다만 runtime polymorphism은 사용할 수 없습니다.

#자체 type-id 시스템

도메인 특화된 type id가 필요할 때 직접 정의합니다.

1
template<typename T>
2
struct TypeId {
3
    static const void* value() {
4
        static const int dummy = 0;
5
        return &dummy;
6
    }
7
};
8

9
// 각 type마다 다른 주소 — 유니크 ID
10
class Base {
11
public:
12
    virtual const void* type_id() const = 0;
13
    virtual ~Base() = default;
14
};
15

16
class Derived : public Base {
17
public:
18
    const void* type_id() const override {
19
        return TypeId<Derived>::value();
20
    }
21
};
22

23
// 사용
24
Base* b = get();
25
if (b->type_id() == TypeId<Derived>::value()) {
26
    auto* d = static_cast<Derived*>(b);
27
}

전역 변수의 주소가 unique type id 역할을 합니다. RTTI 없이도 strict type 비교가 가능합니다.

typeid의 대체 구현이며, Boost.TypeIndex 같은 일부 라이브러리도 같은 아이디어를 사용합니다.

#`dynamic_cast` 대체

1
// dynamic_cast (RTTI 필요)
2
auto* d = dynamic_cast<Derived*>(base);
3

4
// 대체 1 — enum tag + static_cast
5
if (base->type() == NodeType::Derived) {
6
    auto* d = static_cast<Derived*>(base);
7
}
8

9
// 대체 2 — type_id
10
if (base->type_id() == TypeId<Derived>::value()) {
11
    auto* d = static_cast<Derived*>(base);
12
}
13

14
// 대체 3 — visitor (std::variant)
15
std::visit([](auto&& obj) {
16
    using T = std::decay_t<decltype(obj)>;
17
    if constexpr (std::is_same_v<T, Derived>) {
18
        // Derived 전용
19
    }
20
}, variant_obj);

각 패턴이 조금씩 다른 트레이드오프를 가집니다. type set이 닫혀 있고 value semantics를 원한다면 variant가 가장 깔끔합니다.

#std::any — 사용 가능?

std::any는 type-erased container이며 내부적으로 typeid를 사용합니다.

1
#include <any>
2

3
std::any a = 42;
4
auto* p = std::any_cast<int>(&a);   // RTTI 필요

-fno-rtti에서는 컴파일 에러가 발생하므로 임베디드에서는 std::any를 사용할 수 없습니다.

대안은 closed type set의 std::variant입니다.

#임베디드 — Event 시스템

1
// 전통 — virtual
2
class IEvent {
3
public:
4
    virtual ~IEvent() = default;
5
    virtual void dispatch() = 0;
6
};
7

8
class ClickEvent : public IEvent { void dispatch() override { /* */ } };
9
class KeyEvent : public IEvent { void dispatch() override { /* */ } };
10

11
// variant 기반
12
struct ClickEvent { int x, y; };
13
struct KeyEvent { int keycode; };
14
struct TimerEvent { uint32_t ms; };
15

16
using Event = std::variant<ClickEvent, KeyEvent, TimerEvent>;
17

18
void dispatch(const Event& e) {
19
    std::visit([](auto&& ev) {
20
        using T = std::decay_t<decltype(ev)>;
21
        if constexpr (std::is_same_v<T, ClickEvent>) {
22
            handle_click(ev);
23
        } else if constexpr (std::is_same_v<T, KeyEvent>) {
24
            handle_key(ev);
25
        }
26
        // ...
27
    }, e);
28
}

vtable과 RTTI가 모두 0이며 코드 크기를 수 KB 절약할 수 있습니다.

#Exception 처리도 무관

-fno-exceptions와 -fno-rtti를 함께 끄는 것이 일반적인 임베디드 표준입니다.

1
CXXFLAGS += -fno-exceptions -fno-rtti

#자주 보는 함정과 안티패턴

#1. dynamic_cast 호출 후 nullptr 안 체크

RTTI가 없으면 dynamic_cast 자체가 컴파일 에러가 됩니다. 코드 변환이 필요합니다.

#2. typeid 사용

typeid 호출도 컴파일 에러로 떨어집니다. 직접 type_id 시스템이나 enum을 씁니다.

#3. enum tag와 type 일관성 깨짐

1
class Circle : public Shape {
2
public:
3
    Circle() : Shape(ShapeType::Square) {}   // 잘못 — 컴파일 에러 없음
4
};

static_assert나 factory function으로 일관성을 보장합니다.

#4. variant에 큰 type

1
using Event = std::variant<SmallEvent, HugeEvent>;
2
// sizeof(Event) = sizeof(HugeEvent) + 인덱스

큰 type을 분리하거나 pointer를 사용합니다.

#5. std::function의 RTTI 의존

std::function은 내부 type erasure에 typeid를 사용합니다. RTTI를 끄면 일부 기능이 제한되므로 함수 포인터나 etl::delegate로 대체합니다.

#6. exception 일부만 끔

예외와 RTTI는 세트로 끕니다. 한 모듈만 RTTI를 켜 두면 링크 충돌이 발생할 수 있습니다.

#측정 — RTTI 끄기 효과

같은 코드를 RTTI on/off로 비교합니다(STM32F4, 단순한 상속 프로젝트).

1
-frtti -fexceptions:
2
  .text: 52 KB
3
  type info tables: 6 KB
4
  total: 58 KB
5

6
-fno-rtti -fno-exceptions:
7
  .text: 38 KB
8
  type info tables: 0
9
  total: 38 KB
10

11
차이: 20 KB (35% 감소)

큰 프로젝트일수록 차이가 더 벌어집니다. RTTI 끄기는 임베디드의 기본 설정입니다.

#정리

-fno-rtti로 type info table을 제거하면 수 KB를 절약할 수 있습니다.
대안은 세 가지입니다 — enum tag, std::variant(closed set), CRTP(compile-time).
dynamic_cast는 type_id 시스템이나 visitor로 대체합니다.
std::any는 사용할 수 없고 std::function도 부분 제한이 있습니다.
RTTI와 예외는 세트로 켜고 끄는 것이 보통입니다.

#관련 항목

Part 1-02: 컴파일러 플래그 — -fno-rtti
Part 2-08: Static Polymorphism — CRTP
Part 4-06: State Machine — std::variant 활용
GoF 23: Visitor — std::visit

#다음 글

Part 3-09: 스마트 포인터 선택 — unique_ptr, shared_ptr, raw pointer 사이에서 임베디드의 기본 선택을 정리합니다.

Embedded C++ for Real Systems · 27 of 41

임베디드 State Machine 패턴 — Variant·Visitor·Table-driven 비교

타입 안전한 상태 머신 — enum + switch부터 std::variant, etl::fsm까지.

2026년 5월 1일·cpp

CRTP 패턴 분석 — vtable 없는 정적 다형성

Curiously Recurring Template Pattern — virtual 함수 없이 컴파일 타임 다형성. vtable 0, 간접 호출 0.

2026년 4월 29일·cpp

임베디드 HAL 설계 패턴 — Static·Dynamic·Hybrid 비교

범용 HAL 구조 — 벤더 종속성 격리, 다중 보드/MCU 지원, 시리즈 마무리.

2026년 5월 2일·cpp

No-RTTI C++ 설계 — dynamic_cast 제거와 정적 타입 분기

#한 줄 요약

#어떤 문제를 푸는가

#대안 1 — Enum Tag

#헬퍼 매크로

#대안 2 — `std::variant` (C++17)

#가상 함수의 완전 대체

#대안 3 — CRTP (Static Polymorphism)

#자체 type-id 시스템

#`dynamic_cast` 대체

#std::any — 사용 가능?

#임베디드 — Event 시스템

#Exception 처리도 무관

#자주 보는 함정과 안티패턴

#1. dynamic_cast 호출 후 nullptr 안 체크

#2. typeid 사용

#3. enum tag와 type 일관성 깨짐

#4. variant에 큰 type

#5. std::function의 RTTI 의존

#6. exception 일부만 끔

#측정 — RTTI 끄기 효과

#정리

#관련 항목

#다음 글

Embedded C++ for Real Systems · 27 of 41

관련 글

임베디드 State Machine 패턴 — Variant·Visitor·Table-driven 비교

CRTP 패턴 분석 — vtable 없는 정적 다형성

임베디드 HAL 설계 패턴 — Static·Dynamic·Hybrid 비교

이 글을 참조하는 글 (5)

#한 줄 요약

#어떤 문제를 푸는가

#대안 1 — Enum Tag

#헬퍼 매크로

#대안 2 — std::variant (C++17)

#가상 함수의 완전 대체

#대안 3 — CRTP (Static Polymorphism)

#자체 type-id 시스템

#dynamic_cast 대체

#std::any — 사용 가능?

#임베디드 — Event 시스템

#Exception 처리도 무관

#자주 보는 함정과 안티패턴

#1. dynamic_cast 호출 후 nullptr 안 체크

#2. typeid 사용

#3. enum tag와 type 일관성 깨짐

#4. variant에 큰 type

#5. std::function의 RTTI 의존

#6. exception 일부만 끔

#측정 — RTTI 끄기 효과

#정리

#관련 항목

#다음 글

Embedded C++ for Real Systems · 27 of 41

관련 글

임베디드 State Machine 패턴 — Variant·Visitor·Table-driven 비교

CRTP 패턴 분석 — vtable 없는 정적 다형성

임베디드 HAL 설계 패턴 — Static·Dynamic·Hybrid 비교

이 글을 참조하는 글 (5)

#대안 2 — `std::variant` (C++17)

#`dynamic_cast` 대체