Embedded C++ for Real Systems · 33/41

Type-safe Flags 패턴 — Enum Class·Strong Typedef·Tag

2026년 5월 1일 · Hawk · 3분 읽기

cpp embedded enum-class bit-flags type-safe

#한 줄 요약

“enum class 위에 operator|만 정의하면 type-safe bit flag가 됩니다.” 정수 변환을 차단하고 의도를 명확히 드러냅니다.

#어떤 문제를 푸는가

전통적인 C bit flag는 다음과 같이 씁니다.

1
#define FLAG_READ    (1 << 0)
2
#define FLAG_WRITE   (1 << 1)
3
#define FLAG_EXECUTE (1 << 2)
4
#define FLAG_USER    (1 << 3)
5

6
int permissions = FLAG_READ | FLAG_WRITE;
7

8
// 문제
9
int speed = 42;
10
permissions |= speed;   // 무관한 정수 OR — 의미 없음, 컴파일 통과

flag와 일반 정수가 같은 type이므로 섞이는 실수를 컴파일러가 잡지 못합니다.

C++의 enum class와 연산자 정의를 함께 쓰면 type-safe가 됩니다.

1
enum class Permission : uint32_t {
2
    Read    = 1 << 0,
3
    Write   = 1 << 1,
4
    Execute = 1 << 2,
5
    User    = 1 << 3,
6
};
7

8
constexpr Permission operator|(Permission a, Permission b) {
9
    return static_cast<Permission>(
10
        static_cast<uint32_t>(a) | static_cast<uint32_t>(b));
11
}
12

13
Permission p = Permission::Read | Permission::Write;   // OK
14
int speed = 42;
15
p |= speed;   // ERROR — type mismatch

정수와 섞이지 않으며 의도가 명확히 드러납니다.

#기본 패턴

1
enum class Flag : uint32_t {
2
    None     = 0,
3
    Option1  = 1 << 0,
4
    Option2  = 1 << 1,
5
    Option3  = 1 << 2,
6
    All      = Option1 | Option2 | Option3,
7
};
8

9
// 비트 OR
10
constexpr Flag operator|(Flag a, Flag b) noexcept {
11
    return static_cast<Flag>(
12
        static_cast<uint32_t>(a) | static_cast<uint32_t>(b));
13
}
14

15
// 비트 AND
16
constexpr Flag operator&(Flag a, Flag b) noexcept {
17
    return static_cast<Flag>(
18
        static_cast<uint32_t>(a) & static_cast<uint32_t>(b));
19
}
20

21
// 비트 NOT
22
constexpr Flag operator~(Flag a) noexcept {
23
    return static_cast<Flag>(~static_cast<uint32_t>(a));
24
}
25

26
// 비트 XOR
27
constexpr Flag operator^(Flag a, Flag b) noexcept {
28
    return static_cast<Flag>(
29
        static_cast<uint32_t>(a) ^ static_cast<uint32_t>(b));
30
}
31

32
// 복합 연산자
33
constexpr Flag& operator|=(Flag& a, Flag b) noexcept { a = a | b; return a; }
34
constexpr Flag& operator&=(Flag& a, Flag b) noexcept { a = a & b; return a; }
35
constexpr Flag& operator^=(Flag& a, Flag b) noexcept { a = a ^ b; return a; }
36

37
// bool 변환
38
constexpr bool has_flag(Flag a, Flag b) noexcept {
39
    return (static_cast<uint32_t>(a) & static_cast<uint32_t>(b))
40
        == static_cast<uint32_t>(b);
41
}

연산자는 namespace 안이나 enum과 같은 scope에 두어 ADL로 찾도록 합니다.

#사용 예

1
Flag p = Flag::Option1 | Flag::Option2;
2

3
if (has_flag(p, Flag::Option1)) {
4
    // Option1 있음
5
}
6

7
p |= Flag::Option3;       // 추가
8
p &= ~Flag::Option1;      // 제거
9
p ^= Flag::Option2;       // toggle

C++ idiomatic한 형태입니다.

#Template으로 자동화

enum마다 operator를 정의하기는 번거롭습니다. 매크로나 trait로 자동화합니다.

#Trait + concept (C++20)

1
template<typename E>
2
struct enable_bit_flags : std::false_type {};
3

4
template<typename E>
5
constexpr bool enable_bit_flags_v = enable_bit_flags<E>::value;
6

7
template<typename E>
8
concept BitFlags = std::is_enum_v<E> && enable_bit_flags_v<E>;
9

10
// 한 번만 정의
11
template<BitFlags E>
12
constexpr E operator|(E a, E b) noexcept {
13
    using U = std::underlying_type_t<E>;
14
    return static_cast<E>(static_cast<U>(a) | static_cast<U>(b));
15
}
16

17
template<BitFlags E>
18
constexpr E operator&(E a, E b) noexcept {
19
    using U = std::underlying_type_t<E>;
20
    return static_cast<E>(static_cast<U>(a) & static_cast<U>(b));
21
}
22

23
// ... operator~, ^, |=, &=, ^=
24

25
// 사용
26
enum class Permission : uint32_t { Read = 1, Write = 2, Execute = 4 };
27

28
template<>
29
struct enable_bit_flags<Permission> : std::true_type {};
30

31
// 이제 자동
32
Permission p = Permission::Read | Permission::Write;

새 enum을 추가할 때 enable_bit_flags<E> 특수화 한 줄만 더 쓰면 나머지는 자동입니다.

#Macro 버전 (간단)

1
#define DEFINE_BIT_FLAGS(E)                                                   \
2
    constexpr E operator|(E a, E b) noexcept {                                \
3
        using U = std::underlying_type_t<E>;                                  \
4
        return static_cast<E>(static_cast<U>(a) | static_cast<U>(b));         \
5
    }                                                                          \
6
    constexpr E operator&(E a, E b) noexcept {                                \
7
        using U = std::underlying_type_t<E>;                                  \
8
        return static_cast<E>(static_cast<U>(a) & static_cast<U>(b));         \
9
    }                                                                          \
10
    constexpr E operator~(E a) noexcept {                                     \
11
        using U = std::underlying_type_t<E>;                                  \
12
        return static_cast<E>(~static_cast<U>(a));                            \
13
    }                                                                          \
14
    constexpr E& operator|=(E& a, E b) noexcept { a = a | b; return a; }      \
15
    constexpr E& operator&=(E& a, E b) noexcept { a = a & b; return a; }      \
16
    /* ... */
17

18
enum class Permission : uint32_t { Read = 1, Write = 2 };
19
DEFINE_BIT_FLAGS(Permission)

매크로는 C++17 이전 환경에 잘 맞고, C++20 이상에서는 template을 선호합니다.

#임베디드 — Register Bit Flags

ARM Cortex의 register flag를 type-safe하게 다룰 수 있습니다.

1
enum class GpioConfig : uint32_t {
2
    None        = 0,
3
    InputPullUp = 0b001,
4
    InputPullDown = 0b010,
5
    Output      = 0b011,
6
    AlternateFn = 0b100,
7
    AnalogMode  = 0b111,
8
    HighSpeed   = 1 << 4,
9
    OpenDrain   = 1 << 5,
10
};
11

12
template<>
13
struct enable_bit_flags<GpioConfig> : std::true_type {};
14

15
void configure_gpio(int pin, GpioConfig cfg) {
16
    uint32_t reg = GPIOA->MODER;
17
    reg &= ~(0b111 << (pin * 2));
18
    reg |= static_cast<uint32_t>(cfg & GpioConfig::AnalogMode) << (pin * 2);
19
    GPIOA->MODER = reg;
20

21
    if (has_flag(cfg, GpioConfig::HighSpeed)) {
22
        GPIOA->OSPEEDR |= 1 << (pin * 2);
23
    }
24
    if (has_flag(cfg, GpioConfig::OpenDrain)) {
25
        GPIOA->OTYPER |= 1 << pin;
26
    }
27
}
28

29
configure_gpio(5, GpioConfig::Output | GpioConfig::HighSpeed);

#define MODE_OUTPUT 매크로보다 type-safe하며 디버거에서 enum 이름을 그대로 확인할 수 있습니다.

#임베디드 — Status Register Flags

1
enum class UartStatus : uint32_t {
2
    None           = 0,
3
    DataReady      = 1 << 0,
4
    Overrun        = 1 << 1,
5
    NoiseDetected  = 1 << 2,
6
    FramingError   = 1 << 3,
7
    ParityError    = 1 << 4,
8
    AnyError       = Overrun | NoiseDetected | FramingError | ParityError,
9
};
10

11
template<>
12
struct enable_bit_flags<UartStatus> : std::true_type {};
13

14
UartStatus read_status() {
15
    return static_cast<UartStatus>(USART2->SR);
16
}
17

18
void uart_isr() {
19
    auto status = read_status();
20

21
    if (has_flag(status, UartStatus::DataReady)) {
22
        read_data();
23
    }
24
    if (has_flag(status, UartStatus::AnyError)) {
25
        log_error("UART error");
26
        clear_errors();
27
    }
28
}

ISR에서 상태 검사가 명확해집니다.

#To-string for logging

flag 값을 문자열로 출력할 때도 활용합니다.

1
constexpr const char* to_string(GpioConfig cfg) {
2
    // 단일 값은 단순
3
    switch (cfg) {
4
        case GpioConfig::None: return "None";
5
        case GpioConfig::Output: return "Output";
6
        // ...
7
    }
8
    return "Combined";   // 여러 비트
9
}
10

11
// 또는 combined 처리
12
void format_flags(GpioConfig cfg, char* buf, size_t n) {
13
    buf[0] = 0;
14
    if (has_flag(cfg, GpioConfig::HighSpeed)) strncat(buf, "HighSpeed|", n);
15
    if (has_flag(cfg, GpioConfig::OpenDrain)) strncat(buf, "OpenDrain|", n);
16
    // ...
17
    // 마지막 | 제거
18
    size_t len = strlen(buf);
19
    if (len > 0 && buf[len - 1] == '|') buf[len - 1] = 0;
20
}

C++20 이후 reflection이 추가되면 자동 to_string이 가능해집니다. 현재는 수동으로 작성합니다.

#Strongly-typed Flags

C++의 std::bitset처럼 wrapper class로 감싸는 방식입니다.

1
template<typename E>
2
class Flags {
3
    using U = std::underlying_type_t<E>;
4
    U value_;
5

6
public:
7
    constexpr Flags() : value_(0) {}
8
    constexpr Flags(E e) : value_(static_cast<U>(e)) {}
9
    constexpr Flags(U v) : value_(v) {}
10

11
    constexpr Flags operator|(Flags other) const { return value_ | other.value_; }
12
    constexpr Flags operator&(Flags other) const { return value_ & other.value_; }
13
    constexpr Flags operator~() const { return ~value_; }
14

15
    constexpr bool has(E flag) const {
16
        return (value_ & static_cast<U>(flag)) == static_cast<U>(flag);
17
    }
18

19
    constexpr U value() const { return value_; }
20
};
21

22
// 사용
23
Flags<Permission> p;
24
p = Permission::Read;
25
p |= Permission::Write;
26

27
if (p.has(Permission::Read)) { /* */ }

한 번의 operator 정의로 모두 처리할 수 있지만 enum을 직접 쓰는 것보다 약간 무겁습니다.

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

#1. `enum class` 없는 enum

1
enum Permission { Read = 1, Write = 2 };   // 옛 enum
2
int x = Read;   // 암묵 변환

항상 enum class를 사용하고, 옛 enum은 legacy 호환 용도로만 둡니다.

#2. operator 정의 누락

1
enum class Flag : uint32_t { A = 1, B = 2 };
2
auto x = Flag::A | Flag::B;   // ERROR — operator| 없음

매크로나 template으로 자동화합니다.

#3. underlying type 명시 안 함

1
enum class Flag { A = 1 << 30 };   // int 가정 — 32-bit 한계

항상 : uint32_t 같은 underlying type을 명시합니다.

#4. bit position 실수

1
enum class Flag { A = 1, B = 2, C = 3 };   // C는 A|B와 같음 — flag 아님

A = 1 << 0, B = 1 << 1, C = 1 << 2처럼 비트 위치를 명확히 합니다.

#5. enum value 충돌

1
enum class A { X = 1 };
2
enum class B { X = 2 };
3
A::X | B::X;   // type 다름 — 컴파일 에러 (의도된 안전)

같은 enum의 flag끼리만 조합합니다.

#6. Strongly typed flags의 overhead 가정

enum class + operator는 zero-cost이며 컴파일러가 모두 인라인합니다.

#측정 — type-safe vs raw

1
// V1 — raw int
2
int flags = (1 << 0) | (1 << 1);
3

4
// V2 — enum class with operators
5
auto flags = MyFlag::A | MyFlag::B;

어셈블리:

1
V1:
2
    mov  r0, #3       ; 1 | 2 = 3
3

4
V2:
5
    mov  r0, #3       ; 동일

생성된 코드가 완전히 동일하며 zero-cost입니다.

#정리

C의 #define FLAG_X (1<<n) 대신 enum class와 bit operator를 함께 씁니다.
무관한 정수와 섞이지 않으므로 type safety가 보장됩니다.
Template이나 매크로로 operator를 자동 정의합니다.
임베디드의 register flag와 status flag에 적합합니다.
컴파일 결과가 동일하므로 zero-cost입니다.

#관련 항목

Part 2-09: Type Traits — concept 활용
Part 5-01: Register 추상화 — type-safe register
Part 5-02: GPIO 추상화

#다음 글

Part 4-06: State Machine — 상태와 전이를 type-safe하게. enum + switch부터 std::variant까지.

Embedded C++ for Real Systems · 34 of 41

GPIO 추상화 패턴 — Template·Concept으로 보드 독립성

GPIO pin = type — 컴파일 타임에 핀 설정 검증, runtime 비용 0.

2026년 5월 2일·cpp

MMIO Register 추상화 — 타입 안전한 비트 필드 접근

MMIO를 type-safe하게 — volatile, bit field, register wrapper class.

2026년 5월 2일·cpp

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

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

2026년 5월 1일·cpp

Type-safe Flags 패턴 — Enum Class·Strong Typedef·Tag

#한 줄 요약

#어떤 문제를 푸는가

#기본 패턴

#사용 예

#Template으로 자동화

#Trait + concept (C++20)

#Macro 버전 (간단)

#임베디드 — Register Bit Flags

#임베디드 — Status Register Flags

#To-string for logging

#Strongly-typed Flags

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

#1. `enum class` 없는 enum

#2. operator 정의 누락

#3. underlying type 명시 안 함

#4. bit position 실수

#5. enum value 충돌

#6. Strongly typed flags의 overhead 가정

#측정 — type-safe vs raw

#정리

#관련 항목

#다음 글

Embedded C++ for Real Systems · 34 of 41

관련 글

GPIO 추상화 패턴 — Template·Concept으로 보드 독립성

MMIO Register 추상화 — 타입 안전한 비트 필드 접근

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

이 글을 참조하는 글 (3)

#한 줄 요약

#어떤 문제를 푸는가

#기본 패턴

#사용 예

#Template으로 자동화

#Trait + concept (C++20)

#Macro 버전 (간단)

#임베디드 — Register Bit Flags

#임베디드 — Status Register Flags

#To-string for logging

#Strongly-typed Flags

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

#1. enum class 없는 enum

#2. operator 정의 누락

#3. underlying type 명시 안 함

#4. bit position 실수

#5. enum value 충돌

#6. Strongly typed flags의 overhead 가정

#측정 — type-safe vs raw

#정리

#관련 항목

#다음 글

Embedded C++ for Real Systems · 34 of 41

관련 글

GPIO 추상화 패턴 — Template·Concept으로 보드 독립성

MMIO Register 추상화 — 타입 안전한 비트 필드 접근

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

이 글을 참조하는 글 (3)

#1. `enum class` 없는 enum