Embedded C++ for Real Systems · 17/41

Type Traits 임베디드 활용 — SFINAE·is_pod·컴파일 타임 검사

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

cpp embedded type-traits sfinae enable-if compile-time

#한 줄 요약

“Type Traits = type에 대한 컴파일 타임 query.” — 이 타입이 integral인가, signed인가, trivial인가를 묻고 그에 따라 분기합니다.

#어떤 문제를 푸는가

generic 코드에서는 타입에 따라 다른 동작이 필요합니다.

1
template<typename T>
2
void process(T value) {
3
    // T가 integral이면 → bit operation
4
    // T가 floating point면 → epsilon 비교
5
    // T가 pointer면 → null check
6
}

C에서는 불가능합니다(타입 정보가 없음). C++ Type Traits가 컴파일 타임 type query를 제공합니다.

1
template<typename T>
2
void process(T value) {
3
    if constexpr (std::is_integral_v<T>) {
4
        // integral 전용
5
    } else if constexpr (std::is_floating_point_v<T>) {
6
        // float 전용
7
    } else if constexpr (std::is_pointer_v<T>) {
8
        // pointer 전용
9
    }
10
}

if constexpr과 함께 쓰면 런타임 코드 분기가 사라지고, 해당 타입에 맞는 코드만 컴파일됩니다.

#표준 Type Traits (`<type_traits>`)

#Primary categories

1
std::is_void_v<T>
2
std::is_integral_v<T>       // bool, char, int, long ...
3
std::is_floating_point_v<T> // float, double, long double
4
std::is_array_v<T>
5
std::is_pointer_v<T>
6
std::is_reference_v<T>
7
std::is_function_v<T>
8
std::is_class_v<T>          // class, struct
9
std::is_enum_v<T>
10
std::is_union_v<T>

#Composite categories

1
std::is_arithmetic_v<T>   // integral || floating_point
2
std::is_fundamental_v<T>  // arithmetic || void || nullptr_t
3
std::is_object_v<T>       // 변수가 될 수 있는 타입
4
std::is_scalar_v<T>       // arithmetic || enum || pointer

#Type properties

1
std::is_const_v<T>
2
std::is_volatile_v<T>
3
std::is_signed_v<T>
4
std::is_unsigned_v<T>
5
std::is_trivially_copyable_v<T>
6
std::is_standard_layout_v<T>
7
std::is_pod_v<T>          // deprecated in C++20
8
std::is_empty_v<T>
9
std::is_final_v<T>
10
std::is_abstract_v<T>

#Relationships

1
std::is_same_v<T, U>
2
std::is_base_of_v<Base, Derived>
3
std::is_convertible_v<From, To>

#Type transformations

1
std::remove_const_t<T>
2
std::remove_reference_t<T>
3
std::remove_pointer_t<T>
4
std::add_const_t<T>
5
std::decay_t<T>           // 함수/배열 → 포인터, ref/cv 제거
6
std::underlying_type_t<E> // enum의 underlying type
7
std::make_signed_t<T>
8
std::make_unsigned_t<T>

_v는 C++17의 variable template, _t는 C++14의 alias template입니다. 짧고 명확해 사용이 편합니다.

#임베디드 — type-safe register access

1
template<typename T>
2
void write_register(uintptr_t addr, T value) {
3
    static_assert(std::is_trivially_copyable_v<T>,
4
                  "Only trivially copyable types");
5
    static_assert(sizeof(T) <= 4,
6
                  "Register write up to 4 bytes only");
7
    *reinterpret_cast<volatile T*>(addr) = value;
8
}
9

10
write_register<uint32_t>(GPIO_BASE + ODR, 0xFF);   // OK
11
write_register<std::string>(...)                   // ERROR — not trivially copyable
12
write_register<uint64_t>(...)                      // ERROR — too large

잘못된 사용을 컴파일 시점에 차단합니다.

#SFINAE — Substitution Failure Is Not An Error

C++의 오래된 idiom입니다. 템플릿 인스턴스화 실패가 컴파일 에러가 아니라 무시 처리되며, 이를 활용해 조건부 오버로드를 구성합니다.

1
// 정수 전용
2
template<typename T,
3
         std::enable_if_t<std::is_integral_v<T>, int> = 0>
4
void process(T value) {
5
    // integral logic
6
}
7

8
// 부동소수 전용
9
template<typename T,
10
         std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
11
void process(T value) {
12
    // float logic
13
}
14

15
process(5);      // OK — int 버전
16
process(1.5f);   // OK — float 버전
17
process("str");  // ERROR — 둘 다 안 맞음

std::enable_if는 조건이 true이면 정의를 남기고, false이면 substitution failure로 처리해 해당 오버로드를 무시합니다.

C++17의 if constexpr이 대부분의 SFINAE를 대체합니다. 새 코드에서는 if constexpr을 우선합니다.

1
// if constexpr — 훨씬 깔끔
2
template<typename T>
3
void process(T value) {
4
    if constexpr (std::is_integral_v<T>) {
5
        // integral logic
6
    } else if constexpr (std::is_floating_point_v<T>) {
7
        // float logic
8
    } else {
9
        static_assert(sizeof(T) == 0, "Unsupported type");
10
    }
11
}

#void_t — SFINAE 검출 idiom

타입에 특정 멤버나 함수가 있는지를 컴파일 타임에 확인합니다.

1
template<typename, typename = void>
2
struct has_to_string : std::false_type {};
3

4
template<typename T>
5
struct has_to_string<T, std::void_t<decltype(std::declval<T>().to_string())>>
6
    : std::true_type {};
7

8
template<typename T>
9
constexpr bool has_to_string_v = has_to_string<T>::value;

1
struct Foo { std::string to_string() const { return ""; } };
2
struct Bar {};
3

4
static_assert(has_to_string_v<Foo>);
5
static_assert(!has_to_string_v<Bar>);
6

7
template<typename T>
8
void log(T value) {
9
    if constexpr (has_to_string_v<T>) {
10
        write_log(value.to_string());
11
    } else {
12
        write_log("(unsupported type)");
13
    }
14
}

C++20의 concepts가 훨씬 단순한 syntax를 제공합니다.

1
// C++20
2
template<typename T>
3
concept Stringifiable = requires(T t) {
4
    { t.to_string() } -> std::convertible_to<std::string>;
5
};
6

7
template<typename T>
8
void log(T value) {
9
    if constexpr (Stringifiable<T>) {
10
        write_log(value.to_string());
11
    } else {
12
        write_log("(unsupported)");
13
    }
14
}

#임베디드 — Serialization with traits

타입에 따라 다른 직렬화 방법을 골라 씁니다.

1
template<typename T>
2
size_t serialize(uint8_t* buf, T value) {
3
    if constexpr (std::is_integral_v<T>) {
4
        // big-endian으로 정수 직렬화
5
        for (int i = sizeof(T) - 1; i >= 0; --i) {
6
            buf[sizeof(T) - 1 - i] = (value >> (i * 8)) & 0xFF;
7
        }
8
        return sizeof(T);
9
    }
10
    else if constexpr (std::is_floating_point_v<T>) {
11
        // IEEE 754 그대로 (host endian)
12
        std::memcpy(buf, &value, sizeof(T));
13
        return sizeof(T);
14
    }
15
    else if constexpr (std::is_enum_v<T>) {
16
        // underlying type으로
17
        using U = std::underlying_type_t<T>;
18
        return serialize(buf, static_cast<U>(value));
19
    }
20
    else if constexpr (std::is_trivially_copyable_v<T>) {
21
        // POD struct
22
        std::memcpy(buf, &value, sizeof(T));
23
        return sizeof(T);
24
    }
25
    else {
26
        static_assert(sizeof(T) == 0, "Unsupported type for serialization");
27
    }
28
}
29

30
uint8_t buf[16];
31
serialize(buf, uint16_t(0x1234));   // big-endian integer
32
serialize(buf, 1.5f);                // float
33
serialize(buf, MyEnum::Foo);         // underlying int
34
serialize(buf, MyPOD{...});          // memcpy
35
serialize(buf, std::string{});       // ERROR — not trivially copyable

한 함수가 모든 타입을 처리하며, 컴파일러는 해당 분기만 생성합니다.

#std::declval — 인스턴스 없이 type query

std::declval<T>()는 T의 인스턴스가 있다고 가정합니다. 실제로 호출하지 않으며 type만 추론합니다.

1
template<typename T>
2
using result_type = decltype(std::declval<T>().method());
3

4
// T::method()의 반환 타입을 컴파일 타임에 알아냄

decltype과 함께 사용합니다. 호출 시점이 아닌 declare 시점에 유효합니다.

#Custom traits 만들기

1
// "포인터인가 + 정수인가" 조합 trait
2
template<typename T>
3
struct is_pointer_or_integer
4
    : std::bool_constant<std::is_pointer_v<T> || std::is_integral_v<T>> {};
5

6
template<typename T>
7
constexpr bool is_pointer_or_integer_v = is_pointer_or_integer<T>::value;
8

9
static_assert(is_pointer_or_integer_v<int>);
10
static_assert(is_pointer_or_integer_v<int*>);
11
static_assert(!is_pointer_or_integer_v<float>);

표준 trait들의 조합으로, 도메인 특화 검증에 활용합니다.

#임베디드 — register-safe 타입

1
template<typename T>
2
constexpr bool is_register_safe_v =
3
    std::is_trivially_copyable_v<T> &&
4
    !std::is_pointer_v<T> &&
5
    sizeof(T) <= 4 &&
6
    alignof(T) <= 4;
7

8
template<typename T>
9
void write_register(uintptr_t addr, T value) {
10
    static_assert(is_register_safe_v<T>,
11
                  "Type unsafe for register access");
12
    *reinterpret_cast<volatile T*>(addr) = value;
13
}

여러 검증을 하나의 trait로 묶어 새 함수에서 재사용합니다.

#Tag dispatch — SFINAE 대안

함수 오버로드를 tag 객체로 dispatch합니다.

1
struct integral_tag {};
2
struct floating_tag {};
3

4
template<typename T>
5
auto get_tag() {
6
    if constexpr (std::is_integral_v<T>) return integral_tag{};
7
    else if constexpr (std::is_floating_point_v<T>) return floating_tag{};
8
}
9

10
void process_impl(int value, integral_tag) {
11
    // integral
12
}
13

14
void process_impl(float value, floating_tag) {
15
    // float
16
}
17

18
template<typename T>
19
void process(T value) {
20
    process_impl(value, get_tag<T>());
21
}

if constexpr보다 약간 복잡하지만, 오버로드가 명확해 문서로서의 가치가 있습니다. 일반적으로는 if constexpr을 권장합니다.

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

#1. 런타임 if로 type check

1
template<typename T>
2
void f(T x) {
3
    if (typeid(T) == typeid(int)) { /* */ }   // runtime, RTTI 필요
4
}

if constexpr (std::is_same_v<T, int>)로 컴파일 타임에 처리합니다.

#2. trait를 잘못 작성

1
template<typename T>
2
struct has_foo {
3
    static constexpr bool value = /* */ ;
4
};

조건 누락이나 false negative가 생길 수 있으므로, static_assert로 단위 테스트를 작성해 검증합니다.

#3. void_t 패턴 오용

SFINAE 검출이 컴파일러마다 다른 결과를 낼 수 있습니다. 표준 trait나 concept을 우선합니다.

#4. type_traits 미include

1
template<typename T>
2
void f() { static_assert(std::is_integral_v<T>); }
3
// ERROR — <type_traits> 안 include

#5. if constexpr 외 분기에 invalid code

1
template<typename T>
2
void f(T x) {
3
    if constexpr (std::is_integral_v<T>) {
4
        // OK
5
    } else {
6
        x.bar();   // T가 integral이면 — 분기 안 들어가지만 검사
7
    }
8
}

if constexpr의 false branch는 인스턴스화되지 않으므로 의미상 잘못된 코드도 통과할 수 있지만, syntax 자체는 valid해야 합니다.

#6. 사용하지 않는 trait 헤더 include

<type_traits>는 작지만 컴파일 시간을 추가합니다. 쓰지 않으면 제거합니다.

#측정 — type traits의 코드 크기

같은 함수를 virtual, SFINAE, if constexpr로 비교합니다.

1
// V1 — virtual (런타임 분기)
2
class Processor {
3
    virtual void process(int) = 0;
4
    virtual void process(float) = 0;
5
};
6

7
// V2 — SFINAE
8
template<typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
9
void process(T);
10
template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
11
void process(T);
12

13
// V3 — if constexpr
14
template<typename T>
15
void process(T x) {
16
    if constexpr (std::is_integral_v<T>) { /* */ }
17
    else if constexpr (std::is_floating_point_v<T>) { /* */ }
18
}

5개 type별 호출 기준의 코드 크기입니다(STM32F4).

1
V1 (virtual): 460 B (vtable + 가상 호출)
2
V2 (SFINAE): 320 B (per-type 인스턴스)
3
V3 (if constexpr): 280 B (인라인 분기 제거)

if constexpr이 가장 작고 빠르며, modern C++에서 권장됩니다.

#정리

Type Traits는 컴파일 타임 type query이며 <type_traits> 표준 헤더가 제공합니다.
주요 trait는 is_integral, is_pointer, is_trivially_copyable, is_same, decay 등이 있습니다.
SFINAE와 enable_if로 조건부 오버로드를 만들며, C++17의 if constexpr이 이를 대체합니다.
임베디드에서는 type-safe register access, serialization, custom domain traits에 활용합니다.
C++20 concepts가 훨씬 깔끔한 syntax이므로 가능하면 concept을 권장합니다.

#관련 항목

#다음 글

Part 2-10: Concepts (C++20) — template 제약을 시그니처에 명시합니다. SFINAE보다 훨씬 읽기 좋은 컴파일 타임 type 검증을 다룹니다.

Embedded C++ for Real Systems · 18 of 41

Compile-time FSM 구현 — 템플릿으로 상태 전이 검증

constexpr state machine — 컴파일 타임에 전이 검증, runtime 코드 0.

2026년 5월 1일·cpp

consteval과 constinit 분석 — C++20 컴파일 타임 강제 메커니즘

C++20의 컴파일 타임 강제 — consteval은 함수 호출을, constinit은 변수 초기화를 컴파일 타임에 강제합니다.

2026년 4월 29일·cpp

constexpr 고급 활용 — 룩업 테이블·CRC·해시 컴파일 타임 생성

컴파일 타임 sort, search, 문자열 — constexpr 알고리즘의 한계와 가능성.

2026년 4월 29일·cpp

Type Traits 임베디드 활용 — SFINAE·is_pod·컴파일 타임 검사

#한 줄 요약

#어떤 문제를 푸는가

#표준 Type Traits (`<type_traits>`)

#Primary categories

#Composite categories

#Type properties

#Relationships

#Type transformations

#임베디드 — type-safe register access

#SFINAE — Substitution Failure Is Not An Error

#void_t — SFINAE 검출 idiom

#임베디드 — Serialization with traits

#std::declval — 인스턴스 없이 type query

#Custom traits 만들기

#임베디드 — register-safe 타입

#Tag dispatch — SFINAE 대안

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

#1. 런타임 if로 type check

#2. trait를 잘못 작성

#3. void_t 패턴 오용

#4. type_traits 미include

#5. if constexpr 외 분기에 invalid code

#6. 사용하지 않는 trait 헤더 include

#측정 — type traits의 코드 크기

#정리

#관련 항목

#다음 글

Embedded C++ for Real Systems · 18 of 41

관련 글

Compile-time FSM 구현 — 템플릿으로 상태 전이 검증

consteval과 constinit 분석 — C++20 컴파일 타임 강제 메커니즘

constexpr 고급 활용 — 룩업 테이블·CRC·해시 컴파일 타임 생성

이 글을 참조하는 글 (4)

#한 줄 요약

#어떤 문제를 푸는가

#표준 Type Traits (<type_traits>)

#Primary categories

#Composite categories

#Type properties

#Relationships

#Type transformations

#임베디드 — type-safe register access

#SFINAE — Substitution Failure Is Not An Error

#void_t — SFINAE 검출 idiom

#임베디드 — Serialization with traits

#std::declval — 인스턴스 없이 type query

#Custom traits 만들기

#임베디드 — register-safe 타입

#Tag dispatch — SFINAE 대안

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

#1. 런타임 if로 type check

#2. trait를 잘못 작성

#3. void_t 패턴 오용

#4. type_traits 미include

#5. if constexpr 외 분기에 invalid code

#6. 사용하지 않는 trait 헤더 include

#측정 — type traits의 코드 크기

#정리

#관련 항목

#다음 글

Embedded C++ for Real Systems · 18 of 41

관련 글

Compile-time FSM 구현 — 템플릿으로 상태 전이 검증

consteval과 constinit 분석 — C++20 컴파일 타임 강제 메커니즘

constexpr 고급 활용 — 룩업 테이블·CRC·해시 컴파일 타임 생성

이 글을 참조하는 글 (4)

#표준 Type Traits (`<type_traits>`)