Embedded C++ for Real Systems · 18/41

C++20 Concepts 활용 — 템플릿 제약과 가독성 개선

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

cpp embedded concepts cpp20 templates constraints

#한 줄 요약

“Concepts = templates의 type safety.” — 어떤 type을 받는지 함수 시그니처에 명시되며, 에러 메시지가 사람이 읽을 수 있는 형태가 됩니다.

#어떤 문제를 푸는가

C++20 이전의 template은 받을 수 있는 type 제약이 코드에 드러나지 않습니다.

1
template<typename T>
2
T add(T a, T b) {
3
    return a + b;
4
}
5

6
add(1, 2);        // OK
7
add(1.5, 2.5);    // OK
8
add(std::string("a"), std::string("b"));   // OK
9
add(MyStruct{}, MyStruct{});               // ERROR — operator+ 없으면 컴파일 에러

에러 메시지가 수십 줄짜리 내부 detail로 쏟아져 사용자가 이해하기 어렵습니다.

1
error: no match for 'operator+' (operand types are 'MyStruct' and 'MyStruct')
2
note: candidates are:
3
note:  /usr/include/c++/11/bits/stl_iterator.h:1234:5: note: ...
4
note:  /usr/include/c++/11/bits/stl_function.h:567:1: note: ...
5
(continue for 30 lines)

C++20의 concepts는 제약을 시그니처에 명시하고 명확한 에러 메시지를 제공합니다.

#Concept 정의

1
#include <concepts>
2

3
template<typename T>
4
concept Addable = requires(T a, T b) {
5
    { a + b } -> std::same_as<T>;
6
};
7

8
template<Addable T>
9
T add(T a, T b) {
10
    return a + b;
11
}
12

13
add(1, 2);                  // OK
14
add(MyStructWithoutPlus{}, MyStructWithoutPlus{});
15
// ERROR — but with clear message:
16
// error: no matching function for call to 'add'
17
// note: candidate template ignored: constraints not satisfied
18
// note: because 'MyStructWithoutPlus' does not satisfy 'Addable'

에러 메시지가 의미를 가지며, “Addable을 만족하지 않는다”는 사실이 즉시 드러납니다.

#Concept syntax 세 가지

#1. `requires` clause

1
template<typename T>
2
requires std::integral<T>
3
T square(T x) {
4
    return x * x;
5
}

#2. 짧은 form

1
template<std::integral T>
2
T square(T x) {
3
    return x * x;
4
}

#3. abbreviated function template

1
auto square(std::integral auto x) {
2
    return x * x;
3
}

가장 짧고, 함수 시그니처 자체가 제약을 표현하므로 권장됩니다.

#표준 concepts (`<concepts>`)

1
// 기본 type
2
std::integral<T>
3
std::signed_integral<T>
4
std::unsigned_integral<T>
5
std::floating_point<T>
6

7
// 관계
8
std::same_as<T, U>
9
std::derived_from<Derived, Base>
10
std::convertible_to<From, To>
11
std::common_with<T, U>
12

13
// 비교
14
std::equality_comparable<T>
15
std::totally_ordered<T>
16
std::three_way_comparable<T>
17

18
// 호출 가능
19
std::invocable<F, Args...>
20
std::predicate<F, Args...>
21

22
// 생성/이동
23
std::default_initializable<T>
24
std::copy_constructible<T>
25
std::move_constructible<T>
26
std::movable<T>
27
std::copyable<T>
28

29
// 범위 (ranges)
30
std::ranges::range<R>
31
std::ranges::input_range<R>
32
std::ranges::random_access_range<R>

C++ Core Library가 대부분의 표준 concepts를 제공하므로 직접 정의할 일이 많지 않습니다.

#`requires` expression

custom concept 정의의 기본 도구입니다.

1
template<typename T>
2
concept Container = requires(T c) {
3
    typename T::value_type;        // 1. nested type 존재
4
    typename T::iterator;
5
    { c.begin() } -> std::same_as<typename T::iterator>;   // 2. method 시그니처
6
    { c.end() } -> std::same_as<typename T::iterator>;
7
    { c.size() } -> std::convertible_to<std::size_t>;     // 3. 변환 가능 반환
8
};

requires 안에는 4가지 표현이 있습니다.

Simple requirement — expr;로, expr이 valid해야 합니다.
Type requirement — typename T::xxx;로, nested type이 존재해야 합니다.
Compound requirement — { expr } -> Concept;로, expr의 결과가 concept을 만족해야 합니다.
Nested requirement — requires Concept<T>;로, 또 다른 concept을 적용합니다.

#임베디드 — Driver concept

1
template<typename T>
2
concept Driver = requires(T d) {
3
    { d.init() }       -> std::same_as<bool>;
4
    { d.reset() }      -> std::same_as<void>;
5
    { d.is_ready() }   -> std::convertible_to<bool>;
6
};
7

8
template<Driver D>
9
void register_driver(D& driver) {
10
    if (!driver.init()) {
11
        log_error("driver init failed");
12
        return;
13
    }
14
    // ...
15
}

Driver를 만족하지 않는 type은 시그니처에서 거부되므로 function body 안에서 검사를 할 필요가 없습니다.

#임베디드 — 컴파일 타임 dispatch with concepts

if constexpr과 concept을 함께 씁니다.

1
template<typename T>
2
concept HasUserDeserialize = requires(T t, const uint8_t* buf, size_t len) {
3
    { t.deserialize(buf, len) } -> std::same_as<bool>;
4
};
5

6
template<typename T>
7
bool decode(T& obj, const uint8_t* buf, size_t len) {
8
    if constexpr (HasUserDeserialize<T>) {
9
        return obj.deserialize(buf, len);
10
    } else if constexpr (std::is_trivially_copyable_v<T>) {
11
        if (len < sizeof(T)) return false;
12
        std::memcpy(&obj, buf, sizeof(T));
13
        return true;
14
    } else {
15
        static_assert(sizeof(T) == 0,
16
                      "Type must have deserialize() or be trivially copyable");
17
    }
18
}

우선순위가 코드에 그대로 드러나, type별 분기가 자연스럽게 읽힙니다.

#Concept 조합

&&(and)와 ||(or)로 조합합니다.

1
template<typename T>
2
concept NumericSerializable =
3
    std::integral<T> ||
4
    std::floating_point<T>;
5

6
template<typename T>
7
concept LightweightNumeric =
8
    NumericSerializable<T> &&
9
    sizeof(T) <= 4;
10

11
template<LightweightNumeric T>
12
void write_field(T value) {
13
    // ...
14
}
15

16
write_field(int8_t(5));        // OK
17
write_field(float(1.5f));      // OK
18
write_field(double(1.5));      // ERROR — double은 8 byte
19
write_field(std::string());    // ERROR — not numeric

#CRTP + Concepts — 강력한 결합

Part 2-08의 CRTP를 concept으로 명확하게 만듭니다.

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

6
template<LoggerImpl Derived>
7
class LoggerBase {
8
public:
9
    void log(const char* msg) {
10
        static_cast<Derived*>(this)->log_impl(msg);
11
    }
12
};
13

14
class UartLogger : public LoggerBase<UartLogger> {
15
public:
16
    void log_impl(const char* msg) { /* */ }
17
};
18

19
class BadLogger : public LoggerBase<BadLogger> {
20
public:
21
    // log_impl 누락 — 컴파일 에러
22
};
23
// error: BadLogger does not satisfy 'LoggerImpl'

CRTP base의 type 매개변수가 concept을 만족해야 하므로, missing method가 명확한 에러로 잡힙니다.

#Concept으로 SFINAE 대체

1
// SFINAE (C++17)
2
template<typename T,
3
         std::enable_if_t<std::is_integral_v<T>, int> = 0>
4
T abs(T x) {
5
    return x < 0 ? -x : x;
6
}
7

8
// Concept (C++20)
9
template<std::integral T>
10
T abs(T x) {
11
    return x < 0 ? -x : x;
12
}
13

14
// abbreviated (C++20)
15
auto abs(std::integral auto x) {
16
    return x < 0 ? -x : x;
17
}

C++20 쪽이 압도적으로 짧고 명확합니다.

#임베디드 — Range-based 알고리즘

1
#include <ranges>
2

3
template<std::ranges::input_range R>
4
auto sum(R&& range) {
5
    typename std::ranges::range_value_t<R> total{};
6
    for (auto&& val : range) total += val;
7
    return total;
8
}
9

10
int arr[] = {1, 2, 3, 4, 5};
11
auto s = sum(arr);   // 15
12

13
std::array<float, 3> floats = {1.0f, 2.0f, 3.0f};
14
auto sf = sum(floats);   // 6.0f

array, vector, std::array, 사용자 컨테이너 어느 것이든 concept만 만족하면 그대로 동작합니다.

#Concept 오버로드 — 더 specific 우선

1
template<std::integral T>
2
void print(T value) { /* integer 전용 */ }
3

4
template<std::floating_point T>
5
void print(T value) { /* float 전용 */ }
6

7
template<typename T>
8
void print(T value) { /* fallback */ }
9

10
print(1);       // integer 버전
11
print(1.5);     // float 버전
12
print("str");   // fallback

더 제약된 concept이 우선합니다. 오버로드 resolution이 명확해집니다.

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

#1. concept이 너무 복잡함

1
template<typename T>
2
concept Foo = requires(T t) {
3
    { t.method1() } -> std::convertible_to<int>;
4
    { t.method2() } -> std::same_as<void>;
5
    { t.method3(int(0), float(0.0f)) } -> std::same_as<bool>;
6
    typename T::value_type;
7
    typename T::iterator;
8
    requires std::integral<typename T::value_type>;
9
    // ... 20 more
10
};

작은 concept으로 분해해 조합합니다.

#2. requires 표현이 의도와 어긋남

1
template<typename T>
2
concept Foo = requires(T t) {
3
    t.bar();   // 호출만 됨 (반환 타입 무관)
4
    { t.baz() } -> std::same_as<int>;   // 반환 정확히 int
5
    { t.qux() } -> std::convertible_to<int>;   // int로 변환 가능
6
};

표현마다 의미가 다르므로 의도에 맞게 골라 씁니다.

#3. concept 없이 그냥 template

1
template<typename T>
2
T process(T x);   // 어떤 T든 받음

문서성과 사용자 친화성이 떨어집니다. concept으로 제약을 명시합니다.

#4. concept과 macro 혼동

concept은 type system이고 macro는 텍스트 치환이므로 둘은 전혀 다릅니다.

#5. toolchain 미지원

ARM Compiler 6, IAR 일부는 C++20 concepts를 지원하지 않습니다. C++17과 SFINAE 폴백을 쓰거나 toolchain을 업그레이드합니다.

#6. 직접 만든 concept 과용

표준 concept이 이미 있는데도 직접 정의하는 경우가 있습니다. std::integral 대신 MyInt를 새로 만드는 식이 그 예입니다.

#측정 — concept 사용 시 코드 변화

같은 함수를 C++17 SFINAE와 C++20 concept으로 비교합니다.

1
// C++17 — SFINAE
2
template<typename T,
3
         std::enable_if_t<std::is_integral_v<T>, int> = 0>
4
T add(T a, T b) { return a + b; }
5

6
// C++20 — concept
7
template<std::integral T>
8
T add(T a, T b) { return a + b; }

코드 크기는 동일합니다. concept은 컴파일 시점에만 영향을 주며 런타임은 동일합니다.

컴파일 시간은 concept 쪽이 약간 빠릅니다. SFINAE 추론보다 단순하기 때문입니다.

에러 메시지는 concept이 훨씬 짧고 명확합니다.

#C++20 concepts의 실용 가치

에러 메시지 — 가장 큰 이점입니다. 30줄짜리 에러가 1~2줄로 줄어듭니다.
자체 문서화 — 함수 시그니처가 제약을 명시합니다.
오버로드 명확화 — 더 specific한 concept이 우선합니다.
SFINAE 대체 — 짧고 읽기 좋습니다.

#정리

Concepts는 template 제약을 시그니처에 명시하는 C++20 기능입니다.
표준 concepts는 <concepts>와 <ranges>에 풍부하게 준비돼 있습니다.
3가지 syntax를 지원합니다 — requires, template<Concept T>, auto func(Concept auto x).
CRTP와 concept을 함께 쓰면 interface가 명확해지고 누락된 멤버는 명확한 에러로 드러납니다.
SFINAE를 대체하며 짧고 읽기 좋고 에러 메시지가 훨씬 명확합니다.
toolchain 확인이 필수입니다 — GCC 10+, Clang 12+이며 ARM Compiler 6는 부분 지원입니다.

#관련 항목

#다음 글 (Part 3 시작)

Part 3-01: 동적 할당 없이 C++ 쓰기 — 임베디드의 첫 번째 원칙입니다. new, malloc 없이 modern C++를 쓰는 패턴을 다룹니다.

Embedded C++ for Real Systems · 19 of 41

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

Template instantiation의 코드 bloat — 추적, 통제, 공통 부분 분리 패턴.

2026년 4월 29일·cpp

임베디드 Templates 기초 — 타입 안전과 코드 재사용 분석

함수 템플릿과 클래스 템플릿 — 컴파일 타임 다형성으로 type-safe + zero-cost generic 코드.

2026년 4월 29일·cpp

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

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

2026년 4월 29일·cpp

C++20 Concepts 활용 — 템플릿 제약과 가독성 개선

#한 줄 요약

#어떤 문제를 푸는가

#Concept 정의

#Concept syntax 세 가지

#1. `requires` clause

#2. 짧은 form

#3. abbreviated function template

#표준 concepts (`<concepts>`)

#`requires` expression

#임베디드 — Driver concept

#임베디드 — 컴파일 타임 dispatch with concepts

#Concept 조합

#CRTP + Concepts — 강력한 결합

#Concept으로 SFINAE 대체

#임베디드 — Range-based 알고리즘

#Concept 오버로드 — 더 specific 우선

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

#1. concept이 너무 복잡함

#2. requires 표현이 의도와 어긋남

#3. concept 없이 그냥 template

#4. concept과 macro 혼동

#5. toolchain 미지원

#6. 직접 만든 concept 과용

#측정 — concept 사용 시 코드 변화

#C++20 concepts의 실용 가치

#정리

#관련 항목

#다음 글 (Part 3 시작)

Embedded C++ for Real Systems · 19 of 41

관련 글

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

임베디드 Templates 기초 — 타입 안전과 코드 재사용 분석

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

이 글을 참조하는 글 (5)

#한 줄 요약

#어떤 문제를 푸는가

#Concept 정의

#Concept syntax 세 가지

#1. requires clause

#2. 짧은 form

#3. abbreviated function template

#표준 concepts (<concepts>)

#requires expression

#임베디드 — Driver concept

#임베디드 — 컴파일 타임 dispatch with concepts

#Concept 조합

#CRTP + Concepts — 강력한 결합

#Concept으로 SFINAE 대체

#임베디드 — Range-based 알고리즘

#Concept 오버로드 — 더 specific 우선

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

#1. concept이 너무 복잡함

#2. requires 표현이 의도와 어긋남

#3. concept 없이 그냥 template

#4. concept과 macro 혼동

#5. toolchain 미지원

#6. 직접 만든 concept 과용

#측정 — concept 사용 시 코드 변화

#C++20 concepts의 실용 가치

#정리

#관련 항목

#다음 글 (Part 3 시작)

Embedded C++ for Real Systems · 19 of 41

관련 글

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

임베디드 Templates 기초 — 타입 안전과 코드 재사용 분석

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

이 글을 참조하는 글 (5)

#1. `requires` clause

#표준 concepts (`<concepts>`)

#`requires` expression