C++20 Concepts 완벽 가이드 | 템플릿 제약의 새 시대

· 20분 읽기 · 수정 고급 튜토리얼
C++20 Concepts 완벽 가이드 | 템플릿 제약의 새 시대

이 글의 핵심

C++20 Concepts 완벽 가이드에 대한 실전 가이드입니다. 템플릿 제약의 새 시대 등을 예제와 함께 상세히 설명합니다.

C++20 Concepts란? 왜 필요한가

문제 시나리오: 템플릿 에러 메시지 지옥

문제: 템플릿 함수에 잘못된 타입을 넘기면 에러 메시지가 수백 줄로 쏟아집니다.

template<typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    add("hello", "world");  
    // Error: no operator+ for const char*
    // 50줄의 템플릿 인스턴스화 에러 메시지...
}

해결: Concepts는 템플릿 인자에 제약 조건을 명시해, 잘못된 타입이 들어오면 즉시 명확한 에러를 냅니다.

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

template<Addable T>
T add(T a, T b) {
    return a + b;
}

int main() {
    add("hello", "world");
    // Error: const char* does not satisfy Addable
    // 명확하고 짧은 에러 메시지!
}
flowchart TD
    subgraph before["C++17 이전"]
        call1["add(string, string)"]
        inst1["템플릿 인스턴스화"]
        err1["50줄 에러 메시지"]
    end
    subgraph after["C++20 Concepts"]
        call2["add(string, string)"]
        check["Concept 체크"]
        err2["명확한 에러: Addable 위반"]
    end
    call1 --> inst1 --> err1
    call2 --> check --> err2

목차

  1. 기본 문법: concept, requires
  2. 표준 Concepts
  3. 커스텀 Concept 작성
  4. requires 표현식
  5. Concept 조합
  6. 자주 발생하는 문제와 해결법
  7. 프로덕션 패턴
  8. 완전한 예제: 제네릭 컨테이너
  9. SFINAE vs Concepts
  10. 마이그레이션 가이드

1. 기본 문법: concept, requires

Concept 정의

#include <concepts>

// 기본 형태
template<typename T>
concept MyConstraint = /* boolean expression */;

// 예시: 덧셈 가능한 타입
template<typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::same_as<T>;
};

Concept 사용

// 방법 1: template<Concept T>
template<Addable T>
T add(T a, T b) {
    return a + b;
}

// 방법 2: requires 절
template<typename T>
    requires Addable<T>
T add(T a, T b) {
    return a + b;
}

// 방법 3: trailing requires
template<typename T>
T add(T a, T b) requires Addable<T> {
    return a + b;
}

// 방법 4: auto (축약 함수 템플릿)
auto add(Addable auto a, Addable auto b) {
    return a + b;
}

2. 표준 Concepts

타입 분류

#include <concepts>

// 정수 타입
template<std::integral T>
T square(T x) {
    return x * x;
}

// 부동소수점 타입
template<std::floating_point T>
T sqrt_approx(T x) {
    return x / 2;
}

// 부호 있는 정수
template<std::signed_integral T>
T negate(T x) {
    return -x;
}

// 부호 없는 정수
template<std::unsigned_integral T>
T increment(T x) {
    return x + 1;
}

int main() {
    square(5);          // OK: int
    sqrt_approx(9.0);   // OK: double
    negate(-10);        // OK: int
    increment(10u);     // OK: unsigned int
}

관계 Concepts

// 같은 타입
template<typename T, typename U>
    requires std::same_as<T, U>
void func(T a, U b) {
    // T와 U는 같은 타입
}

// 변환 가능
template<typename From, typename To>
    requires std::convertible_to<From, To>
To convert(From value) {
    return static_cast<To>(value);
}

// 파생 관계
template<typename Derived, typename Base>
    requires std::derived_from<Derived, Base>
void process(Derived* ptr) {
    Base* base = ptr;  // OK
}

비교 Concepts

// 동등 비교 가능
template<std::equality_comparable T>
bool is_equal(T a, T b) {
    return a == b;
}

// 완전 순서 비교 가능
template<std::totally_ordered T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

호출 가능 Concepts

// 호출 가능
template<typename F, typename... Args>
    requires std::invocable<F, Args...>
auto call(F func, Args... args) {
    return func(args...);
}

// 조건자 (bool 반환)
template<typename F, typename T>
    requires std::predicate<F, T>
bool test(F pred, T value) {
    return pred(value);
}

객체 Concepts

// 기본 생성 가능
template<std::default_initializable T>
T create() {
    return T{};
}

// 복사 생성 가능
template<std::copy_constructible T>
T duplicate(const T& value) {
    return T(value);
}

// 이동 생성 가능
template<std::move_constructible T>
T transfer(T&& value) {
    return T(std::move(value));
}

3. 커스텀 Concept 작성

Container Concept

template<typename T>
concept Container = requires(T c) {
    // 타입 멤버
    typename T::value_type;
    typename T::iterator;
    
    // 멤버 함수
    { c.size() } -> std::same_as<std::size_t>;
    { c.begin() } -> std::same_as<typename T::iterator>;
    { c.end() } -> std::same_as<typename T::iterator>;
    { c.empty() } -> std::convertible_to<bool>;
};

template<Container C>
void print_size(const C& container) {
    std::cout << "Size: " << container.size() << '\n';
}

int main() {
    std::vector<int> v = {1, 2, 3};
    print_size(v);  // OK
    
    int arr[] = {1, 2, 3};
    // print_size(arr);  // Error: int[] not Container
}

Serializable Concept

template<typename T>
concept Serializable = requires(T obj, std::ostream& os, std::istream& is) {
    { obj.serialize(os) } -> std::same_as<void>;
    { T::deserialize(is) } -> std::same_as<T>;
};

template<Serializable T>
void save(const T& obj, std::ostream& os) {
    obj.serialize(os);
}

template<Serializable T>
T load(std::istream& is) {
    return T::deserialize(is);
}

Numeric Concept

template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

template<Numeric T>
T abs(T value) {
    return value < 0 ? -value : value;
}

template<Numeric T>
T clamp(T value, T min, T max) {
    if (value < min) return min;
    if (value > max) return max;
    return value;
}

4. requires 표현식

단순 요구사항

template<typename T>
concept HasSize = requires(T t) {
    t.size();  // size() 멤버 함수 존재
};

타입 요구사항

template<typename T>
concept HasValueType = requires {
    typename T::value_type;  // value_type 타입 멤버 존재
};

복합 요구사항

template<typename T>
concept Comparable = requires(T a, T b) {
    { a < b } -> std::convertible_to<bool>;
    { a > b } -> std::convertible_to<bool>;
    { a == b } -> std::convertible_to<bool>;
};

중첩 요구사항

template<typename T>
concept ComplexConstraint = requires(T t) {
    // 단순 요구사항
    t.method();
    
    // 타입 요구사항
    typename T::value_type;
    
    // 복합 요구사항
    { t.size() } -> std::same_as<std::size_t>;
    
    // 중첩 요구사항
    requires std::default_initializable<T>;
    requires sizeof(T) <= 64;
};

5. Concept 조합

논리 연산

// AND
template<typename T>
concept SignedIntegral = std::integral<T> && std::signed_integral<T>;

// OR
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

// NOT (부정은 requires 절에서)
template<typename T>
    requires (!std::integral<T>)
void func(T value);

Concept 상속

template<typename T>
concept Movable = std::move_constructible<T> && std::movable<T>;

template<typename T>
concept Copyable = Movable<T> && std::copy_constructible<T>;

template<typename T>
concept Semiregular = Copyable<T> && std::default_initializable<T>;

template<typename T>
concept Regular = Semiregular<T> && std::equality_comparable<T>;

6. 자주 발생하는 문제와 해결법

문제 1: Concept 위반 에러

증상: error: no matching function ... constraints not satisfied.

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

int main() {
    // square(3.14);  // Error: double does not satisfy std::integral
}

해결: 올바른 타입을 전달하거나, Concept을 완화하세요.

template<typename T>
    requires std::integral<T> || std::floating_point<T>
T square(T x) {
    return x * x;
}

int main() {
    square(5);      // OK
    square(3.14);   // OK
}

문제 2: 순환 Concept

원인: Concept A가 B를 참조하고, B가 A를 참조함.

// ❌ 순환
template<typename T>
concept ConceptA = ConceptB<T>;

template<typename T>
concept ConceptB = ConceptA<T>;

// ✅ 올바른 정의
template<typename T>
concept ConceptA = std::integral<T>;

template<typename T>
concept ConceptB = ConceptA<T> && std::signed_integral<T>;

문제 3: requires 표현식 실패

원인: requires 표현식 안에서 컴파일 에러가 나면 Concept이 false가 됩니다.

template<typename T>
concept HasFoo = requires(T t) {
    t.foo();  // foo()가 없으면 false
};

struct A {};
struct B { void foo(); };

static_assert(!HasFoo<A>);  // OK
static_assert(HasFoo<B>);   // OK

7. 프로덕션 패턴

패턴 1: Concept 기반 오버로딩

#include <concepts>
#include <iostream>

// 정수용
template<std::integral T>
void print(T value) {
    std::cout << "Integer: " << value << '\n';
}

// 실수용
template<std::floating_point T>
void print(T value) {
    std::cout << "Float: " << value << '\n';
}

// 문자열용
void print(const std::string& value) {
    std::cout << "String: " << value << '\n';
}

int main() {
    print(42);          // Integer: 42
    print(3.14);        // Float: 3.14
    print("hello"s);    // String: hello
}

패턴 2: 제약 계층

// 기본
template<typename T>
concept Drawable = requires(T t) {
    t.draw();
};

// 색상 지원
template<typename T>
concept ColoredDrawable = Drawable<T> && requires(T t) {
    t.setColor(0, 0, 0);
};

// 애니메이션 지원
template<typename T>
concept AnimatedDrawable = ColoredDrawable<T> && requires(T t) {
    t.animate();
};

// 함수 오버로딩
void render(Drawable auto& obj) {
    obj.draw();
}

void render(ColoredDrawable auto& obj) {
    obj.setColor(255, 0, 0);
    obj.draw();
}

void render(AnimatedDrawable auto& obj) {
    obj.animate();
    obj.draw();
}

패턴 3: Range Concept

template<typename R>
concept Range = requires(R r) {
    std::ranges::begin(r);
    std::ranges::end(r);
};

template<Range R>
void process(R&& range) {
    for (auto&& elem : range) {
        // 처리
    }
}

8. 완전한 예제: 제네릭 알고리즘

정렬 가능한 컨테이너

#include <concepts>
#include <vector>
#include <algorithm>
#include <iostream>

template<typename T>
concept Sortable = requires(T container) {
    typename T::value_type;
    { container.begin() } -> std::same_as<typename T::iterator>;
    { container.end() } -> std::same_as<typename T::iterator>;
    requires std::totally_ordered<typename T::value_type>;
};

template<Sortable C>
void sort_container(C& container) {
    std::sort(container.begin(), container.end());
}

int main() {
    std::vector<int> v = {3, 1, 4, 1, 5};
    sort_container(v);
    
    for (int x : v) {
        std::cout << x << ' ';
    }
    // 1 1 3 4 5
}

9. SFINAE vs Concepts

SFINAE (C++17)

#include <type_traits>

// 정수용
template<typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
T square(T x) {
    return x * x;
}

// 실수용
template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
T square(T x) {
    return x * x;
}

Concepts (C++20)

// 정수용
template<std::integral T>
T square(T x) {
    return x * x;
}

// 실수용
template<std::floating_point T>
T square(T x) {
    return x * x;
}

비교:

항목SFINAEConcepts
가독성낮음높음
에러 메시지복잡함명확함
컴파일 속도느림빠름
오버로딩복잡함간단함

10. 마이그레이션 가이드

enable_if → Concepts

Before (C++17):

template<typename T>
std::enable_if_t<std::is_integral_v<T>, T>
add(T a, T b) {
    return a + b;
}

After (C++20):

template<std::integral T>
T add(T a, T b) {
    return a + b;
}

SFINAE → Concepts

Before:

template<typename T, typename = void>
struct has_size : std::false_type {};

template<typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>> : std::true_type {};

template<typename T>
std::enable_if_t<has_size<T>::value, std::size_t>
get_size(const T& container) {
    return container.size();
}

After:

template<typename T>
concept HasSize = requires(T t) {
    { t.size() } -> std::convertible_to<std::size_t>;
};

template<HasSize T>
std::size_t get_size(const T& container) {
    return container.size();
}

정리

개념설명
Concept템플릿 제약 조건
requires제약 명시
표준 Concepts<concepts> 헤더 제공
커스텀 Conceptconcept Name = requires { ... }
오버로딩Concept 기반 함수 오버로딩

C++20 Concepts는 템플릿 에러를 명확히 하고, 코드 가독성을 높이며, SFINAE를 대체하는 현대적인 방법입니다.

FAQ

Q1: Concepts vs SFINAE?

A: Concepts가 가독성, 에러 메시지, 컴파일 속도 모두 우수합니다. C++20 이상이면 Concepts를 사용하세요.

Q2: requires 표현식이 뭔가요?

A: requires(T t) { ... } 안에 타입이 만족해야 할 조건을 명시합니다. 멤버 함수, 타입 멤버, 연산자 등을 체크할 수 있습니다.

Q3: auto와 Concept을 같이 쓸 수 있나요?

A: 네. void func(std::integral auto x)처럼 축약 함수 템플릿으로 사용할 수 있습니다. 간결하고 명확합니다.

Q4: Concept을 조합할 수 있나요?

A: 네. &&, ||로 조합하거나, 다른 Concept을 참조해 계층을 만들 수 있습니다.

Q5: 컴파일러 지원은?

A:

  • GCC 10+: 완전 지원
  • Clang 10+: 완전 지원
  • MSVC 2019 (16.3+): 완전 지원

Q6: Concepts 학습 리소스는?

A:

한 줄 요약: C++20 Concepts로 템플릿 제약을 명확히 하고 에러를 개선할 수 있습니다. 다음으로 Coroutines를 읽어보면 좋습니다.

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

  • C++20 Modules 완벽 가이드 | 헤더 파일을 넘어서
  • C++20 Coroutines 완벽 가이드 | 비동기 프로그래밍의 새 시대
  • C++ SFINAE | “Substitution Failure Is Not An Error” 가이드
  • C++ enable_if | “조건부 컴파일” 가이드

관련 글

  • C++ auto 타입 추론 | 복잡한 타입을 컴파일러에 맡기기
  • C++ CTAD |
  • C++ Concepts와 Constraints |
  • C++20 consteval 완벽 가이드 | 컴파일 타임 전용 함수
  • C++ constexpr if |