When should I use concepts?

Whenever template requirements should be readable in the signature and produce short, actionable compiler errors.

None—concept checks happen at compile time.

Concepts are usually clearer; legacy codebases still rely heavily on SFINAE.

Use SFINAE, `enable_if`, and `static_assert` patterns.

[2026] C++ Concepts and Constraints | Type Requirements in C++20

2026년 3월 12일 · 12분 읽기 · 수정 2026년 4월 7일 Advanced Tutorial

이 글의 핵심

C++20 concepts and constraints: requires clauses, standard concepts, custom concepts, and how they replace verbose SFINAE for clearer template errors.

What are concepts?

Concepts give explicit constraints on template parameters. Instead of cryptic SFINAE errors like “no matching function for call to sort”, concepts produce clear messages: “T does not satisfy Sortable: missing operator<”. Real-world benefit: In production codebases with hundreds of templates, concepts reduce debugging time from hours to minutes. They also serve as inline documentation—reading template<Sortable T> is clearer than template<typename T, enable_if_t<...>>. 아래 코드는 cpp를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 실행 예제
template<typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
};
template<Addable T>
T add(T a, T b) {
    return a + b;
}

Compiler support: GCC 10+, Clang 10+, MSVC 2019 16.8+ all support C++20 concepts. For older compilers, use SFINAE with enable_if.

Basic usage

아래 코드는 cpp를 사용한 구현 예제입니다. 필요한 모듈을 import하고. 코드를 직접 실행해보면서 동작을 확인해보세요.

#include <concepts>
template<std::integral T>
T square(T value) {
    return value * value;
}

Standard concepts (overview)

#include <concepts>
// integral<T>, floating_point<T>, equality_comparable<T>, etc.

Custom concepts

다음은 cpp를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

template<typename T>
concept Container = requires(T t) {
    typename T::value_type;
    { t.begin() } -> std::same_as<typename T::iterator>;
    { t.end() } -> std::same_as<typename T::iterator>;
    { t.size() } -> std::convertible_to<std::size_t>;
};
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;
template<typename T>
concept Printable = requires(std::ostream& os, T t) {
    { os << t } -> std::convertible_to<std::ostream&>;
};

Generic function example

아래 코드는 cpp를 사용한 구현 예제입니다. 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

template<Numeric T>
T average(const std::vector<T>& values) {
    if (values.empty()) return T{};
    T sum{};
    for (const auto& v : values) sum += v;
    return sum / static_cast<T>(values.size());
}

`requires` clauses

아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

template<typename T>
requires std::integral<T>
T square(T value) { return value * value; }
template<typename T>
requires requires(T t) {
    { t.size() } -> std::convertible_to<std::size_t>;
}
std::size_t getSize(const T& c) { return c.size(); }

Concepts vs SFINAE

Concepts typically replace dense enable_if with readable requirements on the template line.

FAQ

See the Korean original for extended examples (sorting, iterators, hashable types). Behavior and code are unchanged.

Keywords

C++, concepts, constraints, requires, C++20