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

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

8
class Circle : public Shape {
9
    int r;
10
public:
11
    int area() const override { return 3 * r * r; }
12
};
13

14
// CRTP — virtual 없이
15
template<typename Derived>
16
class Shape {
17
public:
18
    int area() const {
19
        return static_cast<const Derived*>(this)->area_impl();
20
    }
21
};
22

23
class Circle : public Shape<Circle> {
24
    int r;
25
public:
26
    int area_impl() const { return 3 * r * r; }
27
};

1
template<typename Derived>
2
class Base {
3
public:
4
    void interface_method() {
5
        // Derived의 method 호출
6
        static_cast<Derived*>(this)->impl_method();
7
    }
8
};
9

10
class Concrete : public Base<Concrete> {   // 자신을 template 매개변수로
11
public:
12
    void impl_method() {
13
        // 실제 구현
14
    }
15
};

1
template<typename Derived>
2
class LoggerBase {
3
public:
4
    void log(const char* msg) {
5
        derived()->log_impl(msg);
6
    }
7

8
    void log_error(const char* msg) {
9
        derived()->log_impl("[ERROR] ");
10
        derived()->log_impl(msg);
11
    }
12

13
protected:
14
    Derived* derived() {
15
        return static_cast<Derived*>(this);
16
    }
17
};
18

19
class UartLogger : public LoggerBase<UartLogger> {
20
public:
21
    void log_impl(const char* msg) {
22
        while (*msg) {
23
            USART2->DR = *msg++;
24
            while (!(USART2->SR & USART_SR_TC));
25
        }
26
    }
27
};
28

29
class FileLogger : public LoggerBase<FileLogger> {
30
public:
31
    void log_impl(const char* msg) {
32
        fwrite(msg, 1, strlen(msg), file_);
33
    }
34
private:
35
    FILE* file_;
36
};
37

38
UartLogger uart;
39
uart.log("hello");      // 컴파일 타임에 UartLogger::log_impl 호출

1
# 전통 virtual
2
ldr     r3, [r0]         ; vptr 로드
3
ldr     r3, [r3]         ; vtable에서 함수 주소
4
blx     r3               ; 간접 호출 — branch prediction 어려움
5

6
# CRTP
7
bl      UartLogger::log_impl    ; 직접 호출 — 인라인 가능

1
// virtual — runtime polymorphism
2
std::vector<Shape*> shapes;   // 다른 Shape 타입 섞임 OK
3
shapes.push_back(new Circle);
4
shapes.push_back(new Square);
5
for (auto* s : shapes) {
6
    s->area();   // 각자의 area 호출
7
}
8

9
// CRTP — compile-time
10
Circle c;
11
Square s;
12
c.area();   // OK
13
s.area();   // OK
14
// 한 컨테이너에 섞기 어려움 (다른 base type)

1
template<typename Derived>
2
class PeripheralBase {
3
public:
4
    void init() {
5
        derived()->init_impl();
6
    }
7

8
    void send(uint8_t b) {
9
        derived()->send_impl(b);
10
    }
11

12
    void send_buffer(const uint8_t* data, size_t len) {
13
        for (size_t i = 0; i < len; ++i) {
14
            derived()->send_impl(data[i]);
15
        }
16
    }
17

18
private:
19
    Derived* derived() {
20
        return static_cast<Derived*>(this);
21
    }
22
};
23

24
class Uart2 : public PeripheralBase<Uart2> {
25
public:
26
    void init_impl() { /* */ }
27
    void send_impl(uint8_t b) {
28
        while (!(USART2->SR & USART_SR_TXE));
29
        USART2->DR = b;
30
    }
31
};
32

33
class Spi1 : public PeripheralBase<Spi1> {
34
public:
35
    void init_impl() { /* */ }
36
    void send_impl(uint8_t b) {
37
        SPI1->DR = b;
38
        while (!(SPI1->SR & SPI_SR_TXE));
39
    }
40
};
41

42
Uart2 uart;
43
uart.send_buffer(data, 100);   // 인라인 가능

1
template<typename Derived>
2
struct Comparable {
3
    bool operator!=(const Derived& other) const {
4
        return !(static_cast<const Derived*>(this)->operator==(other));
5
    }
6
    bool operator>(const Derived& other) const {
7
        return other < *static_cast<const Derived*>(this);
8
    }
9
    bool operator<=(const Derived& other) const {
10
        return !(*static_cast<const Derived*>(this) > other);
11
    }
12
    bool operator>=(const Derived& other) const {
13
        return !(*static_cast<const Derived*>(this) < other);
14
    }
15
};
16

17
class Version : public Comparable<Version> {
18
public:
19
    int major, minor, patch;
20

21
    bool operator==(const Version& o) const {
22
        return major == o.major && minor == o.minor && patch == o.patch;
23
    }
24
    bool operator<(const Version& o) const {
25
        if (major != o.major) return major < o.major;
26
        if (minor != o.minor) return minor < o.minor;
27
        return patch < o.patch;
28
    }
29
};
30

31
Version v1{1, 0, 0}, v2{1, 2, 0};
32
bool b = v1 < v2;    // operator< — 직접 구현
33
bool c = v1 >= v2;   // Comparable이 자동 제공 → v1 < v2 → not

1
template<typename D> struct Base {};
2
class A : Base<A> {};
3
class B : Base<B> {};
4

5
// Base<A>와 Base<B>는 다른 타입
6
// "Base를 받는 함수"가 자연스럽지 않음

1
// C++20 concept
2
template<typename T>
3
concept LoggerLike = requires(T t, const char* msg) {
4
    t.log(msg);
5
};
6

7
void log_all(LoggerLike auto& logger, ...) {
8
    // 어떤 Logger든 받음
9
}

1
template<typename Derived>
2
class Driver {
3
public:
4
    void init() {
5
        static_assert(requires(Derived d) { d.init_impl(); },
6
                      "Derived must implement init_impl");
7
        static_cast<Derived*>(this)->init_impl();
8
    }
9
};

1
template<typename D>
2
class Base {
3
public:
4
    void foo() {
5
        static_cast<D*>(this)->private_method();   // ERROR
6
    }
7
};

1
Base<Derived>* ptr = new Derived;
2
delete ptr;   // Base의 destructor만 호출 — Derived 자원 누수

1
template<typename D>
2
class Base {
3
public:
4
    void copy_from(const Base& other) {
5
        *static_cast<D*>(this) = *static_cast<const D*>(&other);
6
    }
7
};

1
class Concrete : public BaseA<Concrete>, public BaseB<Concrete>, public BaseC<Concrete> {};

1
template<typename T>
2
concept Logger = requires(T t, const char* msg) {
3
    { t.log_impl(msg) } -> std::same_as<void>;
4
};
5

6
template<Logger Derived>   // ← Derived는 Logger를 만족해야 함
7
class LoggerBase {
8
public:
9
    void log(const char* msg) {
10
        static_cast<Derived*>(this)->log_impl(msg);
11
    }
12
};

1
template<typename D>
2
class Base {};   // 비어 있음
3

4
class Concrete : public Base<Concrete> {};

1
template<typename D>
2
class Base {
3
public:
4
    virtual void method() { /* */ }   // virtual + CRTP는 모순
5
};

1
template<typename D> struct A { void foo(); };
2
template<typename D> struct B { void foo(); };
3
class C : public A<C>, public B<C> {};
4
C c;
5
c.foo();   // ERROR — A::foo와 B::foo 충돌

1
# Virtual
2
class Logger { virtual void log_impl(const char*); };
3
class UartLogger : public Logger { void log_impl(...) override; };
4

5
uart_logger.log("hello");
6
# 어셈블리:
7
ldr     r3, [r0]         ; vptr 로드
8
ldr     r3, [r3, #4]     ; vtable에서 log_impl 주소
9
blx     r3               ; 간접 호출
10

11
# vtable 크기: 12 B (Logger)
12
# vptr: 4 B (UartLogger 인스턴스마다)
13

14
# CRTP
15
template<typename D> class LoggerBase { void log(...); };
16
class UartLogger : public LoggerBase<UartLogger> { void log_impl(...); };
17

18
uart_logger.log("hello");
19
# 어셈블리:
20
bl      UartLogger::log_impl   ; 직접 호출 — 인라인 가능
21

22
# vtable: 0
23
# vptr: 0