Template 비용 분석 — 코드 폭증·인스턴스화·디버그 정보 측정

1
template<typename T>
2
void process(T value) {
3
    // 200 lines of logic
4
    if (value > threshold) { /* */ }
5
    transform(value);
6
    log(value);
7
    notify(value);
8
    // ...
9
}
10

11
process<int>(1);
12
process<long>(2);
13
process<float>(3.0f);
14
process<double>(4.0);
15
process<MyClass>(obj);

1
// BAD — 전체 템플릿
2
template<typename T>
3
void process(T value) {
4
    if (value > 100) {
5
        log_warning();      // 비-템플릿이지만 인스턴스마다 호출
6
        do_cleanup();       // 같음
7
        notify_system();    // 같음
8
    }
9
    write_to_buffer(value); // 이 부분만 T 의존
10
}
11

12
// GOOD — 공통 부분 분리
13
void process_common(bool above_threshold) {
14
    if (above_threshold) {
15
        log_warning();
16
        do_cleanup();
17
        notify_system();
18
    }
19
}
20

21
template<typename T>
22
void process(T value) {
23
    process_common(value > 100);
24
    write_to_buffer(value);   // 작은 템플릿 부분
25
}

1
Before: 3344 B
2
After:
3
  process_common              : 280 B (한 번만)
4
  process<int> 등 5개         : 80 B × 5 = 400 B
5
  total                       : 680 B (-80%)

1
// BAD — 5개 vector
2
std::vector<int> ints;
3
std::vector<float> floats;
4
std::vector<Order> orders;
5
// ...
6

7
// GOOD — variant
8
std::variant<int, float, Order> v;
9
std::vector<decltype(v)> mixed;

1
std::visit([](auto&& val) {
2
    using T = std::decay_t<decltype(val)>;
3
    if constexpr (std::is_same_v<T, int>) {
4
        process_int(val);
5
    } else if constexpr (std::is_same_v<T, float>) {
6
        process_float(val);
7
    }
8
    // ...
9
}, v);

1
// BAD — 각 크기마다 별도 인스턴스
2
template<typename T, size_t N>
3
class Buffer {
4
    T data[N];
5
    // ...
6
};
7

8
Buffer<int, 16> a;
9
Buffer<int, 32> b;
10
Buffer<int, 64> c;
11
// 3개 다른 클래스 — 코드 3배

1
// GOOD — 크기를 런타임으로 (또는 공통 base)
2
template<typename T>
3
class BufferBase {
4
protected:
5
    T* data_;
6
    size_t capacity_;
7
    size_t size_ = 0;
8

9
    BufferBase(T* data, size_t cap) : data_(data), capacity_(cap) {}
10

11
    bool push_impl(const T& v) {
12
        if (size_ >= capacity_) return false;
13
        data_[size_++] = v;
14
        return true;
15
    }
16
};
17

18
template<typename T, size_t N>
19
class Buffer : public BufferBase<T> {
20
    T storage_[N];
21
public:
22
    Buffer() : BufferBase<T>(storage_, N) {}
23
};

1
// BAD — virtual로 다형성
2
class Base {
3
public:
4
    virtual void process() = 0;
5
};
6

7
class A : public Base { void process() override { /* */ } };
8
class B : public Base { void process() override { /* */ } };
9

10
// GOOD — if constexpr (closed set)
11
template<typename T>
12
void process(T& obj) {
13
    if constexpr (std::is_same_v<T, A>) {
14
        // A 전용 code
15
    } else if constexpr (std::is_same_v<T, B>) {
16
        // B 전용 code
17
    }
18
}

1
template<typename T>
2
void func(T x) {
3
    static_assert(sizeof(T) == 0, __PRETTY_FUNCTION__);
4
    // 컴파일 에러 메시지에 인스턴스화 정보
5
}

1
target_precompile_headers(my_target PRIVATE common.h)

1
# CMake 3.16+
2
set_target_properties(my_target PROPERTIES UNITY_BUILD ON)

1
template<typename T>
2
T abs(T x) { return x < 0 ? -x : x; }

1
namespace detail {
2
    template<typename T>
3
    void helper(T x) { /* large */ }
4
}

1
Top template instances by total size:
2

3
1. std::function<...>          : 4 instances, 1.8 KB
4
2. RingBuffer<...>             : 6 instances, 1.2 KB
5
3. EventDispatcher<...>        : 3 instances, 0.9 KB
6
4. Logger<...>                 : 4 instances, 0.6 KB
7
5. std::optional<...>          : 12 instances, 0.4 KB (small)
8
...
9

10
Total template overhead: ~5.5 KB (8% of code section)

1
// container.cppm — module
2
export module container;
3

4
export template<typename T>
5
class Container {
6
    // ...
7
};