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

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;
}

비교:

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

---

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> 헤더 제공
커스텀 Concept	concept 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:

• cppreference - Constraints and concepts
• “C++20: The Complete Guide” by Nicolai Josuttis
• “C++ Templates: The Complete Guide” 2nd Edition 한 줄 요약: 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 |

심화 부록: 구현·운영 관점

이 부록은 앞선 본문에서 다룬 주제(「C++20 Concepts 완벽 가이드 | 템플릿 제약의 새 시대」)를 구현·런타임·운영 관점에서 다시 압축합니다. 도메인별 세부 구현은 글마다 다르지만, 입력 검증 → 핵심 연산 → 부작용(I/O·네트워크·동시성) → 관측의 흐름으로 장애를 나누면 원인 추적이 빨라집니다.

내부 동작과 핵심 메커니즘

flowchart TD
  A[입력·요청·이벤트] --> B[파싱·검증·디코딩]
  B --> C[핵심 연산·상태 전이]
  C --> D[부작용: I/O·네트워크·동시성]
  D --> E[결과·관측·저장]

sequenceDiagram
  participant C as 클라이언트/호출자
  participant B as 경계(런타임·게이트웨이·프로세스)
  participant D as 의존성(API·DB·큐·파일)
  C->>B: 요청/이벤트
  B->>D: 조회·쓰기·RPC
  D-->>B: 지연·부분 실패·재시도 가능
  B-->>C: 응답 또는 오류(코드·상관 ID)

• 불변 조건(Invariant): 버퍼 경계, 프로토콜 상태, 트랜잭션 격리, FD 상한 등 단계별로 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
• 결정성: 순수 층과 시간·네트워크·스케줄에 의존하는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
• 경계 비용: 직렬화, 인코딩, syscall 횟수, 락 경합, 할당·GC, 캐시 미스를 의심 목록에 둡니다.
• 백프레셔: 생산자가 소비자보다 빠를 때 버퍼·큐·스트림에서 속도를 줄이는 신호를 어디에 둘지 정의합니다.

프로덕션 운영 패턴

영역	운영 관점 질문
관측성	요청 단위 상관 ID, 에러율·지연 p95/p99, 의존성 타임아웃·재시도가 대시보드에 보이는가
안전성	입력 검증·권한·비밀·감사 로그가 코드 경로마다 일관적인가
신뢰성	재시도는 멱등 연산에만 적용되는가, 서킷 브레이커·백오프·DLQ가 있는가
성능	캐시·배치 크기·커넥션 풀·인덱스·백프레셔가 데이터 규모에 맞는가
배포	롤백 룬북, 카나리/블루그린, 마이그레이션·피처 플래그가 문서화되어 있는가
용량	피크 트래픽·디스크·FD·스레드 풀 상한을 주기적으로 검증하는가

스테이징은 데이터 양·네트워크 RTT·동시성을 프로덕션에 가깝게 맞출수록 재현율이 올라갑니다.

확장 예시: 엔드투엔드 미니 시나리오

앞선 본문 주제(「C++20 Concepts 완벽 가이드 | 템플릿 제약의 새 시대」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.

1. 입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
2. 핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
3. 실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
4. 호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
5. 부하 후 검증: 피크 대비 p95/p99, 에러율, 리소스 상한, 알림 임계값을 점검한다.

handle(request):
  ctx = newCorrelationId()
  validated = validateSchema(request)
  authorize(validated, ctx)
  result = domainCore(validated)
  persistOrEmit(result, idempotentKey)
  recordMetrics(ctx, latency, outcome)
  return result

문제 해결(Troubleshooting)

증상	가능 원인	조치
간헐적 실패	레이스, 타임아웃, 외부 의존성, DNS	최소 재현 스크립트, 분산 트레이스·로그 상관관계, 재시도·서킷 설정 점검
성능 저하	N+1, 동기 I/O, 락 경합, 과도한 직렬화, 캐시 미스	프로파일러·APM으로 핫스팟 확인 후 한 가지씩 제거
메모리 증가	캐시 무제한, 구독/리스너 누수, 대용량 버퍼, 커넥션 미반납	상한·TTL·힙/FD 스냅샷 비교
빌드·배포만 실패	환경 변수, 권한, 플랫폼 차이, lockfile	CI 로그와 로컬 diff, 런타임·이미지 버전 핀
설정 불일치	프로필·시크릿·기본값, 리전	스키마 검증된 설정 단일 소스와 배포 매트릭스 표준화
데이터 불일치	비멱등 재시도, 부분 쓰기, 캐시 무효화 누락	멱등 키·아웃박스·트랜잭션 경계 재검토

권장 순서: (1) 최소 재현 (2) 최근 변경 범위 축소 (3) 환경·의존성 차이 (4) 관측으로 가설 검증 (5) 수정 후 회귀·부하 테스트.

배포 전에는 git add → git commit → git push 후 npm run deploy 순서를 권장합니다.

---

이 글에서 다루는 키워드 (관련 검색어)

C++, concept, cpp20, template, constraint, requires 등으로 검색하시면 이 글이 도움이 됩니다.