MENU
  1. ホーム
  2. C++
  3. C++20 Concepts로 타입 제약을 명확하게 표현하기

C++20 Concepts로 타입 제약을 명확하게 표현하기

C++

C++20에서 새롭게 도입된 Concepts 기능은 타입 제약을 명확하게 정의하고, 코드의 안정성과 가독성을 높이는 데 중요한 역할을 합니다. Concepts는 템플릿을 사용할 때 타입에 대한 조건을 간단하게 표현할 수 있게 해 주며, 오류를 컴파일 타임에 미리 발견할 수 있도록 도와줍니다. 본 기사에서는 Concepts의 기본 개념과 사용법을 설명하고, 이를 실제 코드에서 어떻게 활용할 수 있는지 다양한 예제와 함께 다뤄보겠습니다.
C++20에서 도입된 Concepts는 템플릿에서 타입 제약을 명확하게 정의하는 기능입니다. Concepts를 사용하면 템플릿 파라미터가 특정 조건을 만족하는지 검사할 수 있으며, 이로 인해 타입 오류를 컴파일 타임에 미리 방지할 수 있습니다. 이전에는 템플릿을 사용할 때 SFINAE(대체 실패는 오류가 아니다)를 이용해 타입 제약을 구현했지만, Concepts는 이를 보다 직관적이고 명확하게 표현할 수 있게 합니다.

Concepts는 concept 키워드를 사용하여 정의하며, 각 Concept은 하나 이상의 제약 조건을 가질 수 있습니다. 이 기능을 통해 템플릿 함수나 클래스가 받는 타입에 대해 보다 세밀하게 제어할 수 있습니다. 예를 들어, 더하기 연산이 가능한 타입만 허용하는 Concept을 만들거나, 특정 조건을 만족하는 타입들만 특정 함수에 전달할 수 있습니다.
C++20에서 Concepts는 concept 키워드를 사용하여 정의합니다. 이를 통해 템플릿 파라미터가 특정 조건을 만족하는지 검사할 수 있습니다. 기본적인 문법은 다음과 같습니다:

template<typename T>
concept ConceptName = 조건식;

ConceptName은 정의하려는 Concept의 이름이고, 조건식은 이 Concept이 만족해야 하는 조건입니다. 조건식은 해당 타입이 특정 연산을 지원하는지 등을 검사하는 내용입니다. 예를 들어, 두 타입이 더하기 연산을 지원하는지 확인하는 Concept을 정의할 수 있습니다.

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

위 예제에서 Addable Concept은 T 타입이 + 연산자를 지원하고, 연산 결과가 T 타입이어야 한다는 조건을 검사합니다. requires 키워드를 사용하여 이와 같은 제약을 표현할 수 있으며, 이 Concept은 a + b가 유효하고 그 결과가 T 타입임을 요구합니다.
Concept을 사용하면 함수 템플릿에서 타입 제약을 간단하고 직관적으로 표현할 수 있습니다. 예를 들어, Addable Concept을 사용하여 더하기 연산이 가능한 타입만 함수 템플릿의 인수로 받도록 제한할 수 있습니다.

다음은 Addable Concept을 사용하는 예시입니다:

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

위 코드에서 add 함수는 Addable Concept을 만족하는 타입만 받습니다. 즉, T가 + 연산을 지원하는 타입이어야만 add 함수가 호출될 수 있습니다. 이를 통해 코드에서 예상할 수 없는 타입 오류를 컴파일 타임에 미리 방지할 수 있습니다.

만약 Addable을 만족하지 않는 타입을 전달하면, 컴파일러는 타입이 해당 Concept을 충족하지 않는다는 오류를 발생시킵니다. 예를 들어, std::string을 사용하더라도 + 연산을 지원하는 문자열 타입이라면 문제가 없지만, 다른 타입의 데이터를 전달하면 컴파일러에서 오류를 감지하고 명확한 오류 메시지를 제공합니다.
Concepts는 기본적인 제약뿐만 아니라, 여러 제약을 결합하여 복합적인 조건을 만들 수 있습니다. 여러 조건을 동시에 만족해야 하는 타입을 제한하는 방식은 매우 유용합니다. 예를 들어, 하나의 Concept을 여러 개의 다른 Concept과 결합하여, 두 타입이 더하기 연산뿐만 아니라 비교 연산도 지원하도록 제약할 수 있습니다.

다음은 Addable과 Comparable 두 Concept을 결합하여, 더하기 연산과 비교 연산을 모두 지원하는 타입만 허용하는 예시입니다:

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

위 코드에서는 Addable과 Comparable을 결합하여, T 타입이 + 연산과 < 연산을 모두 지원하는지 체크합니다. && 연산자를 사용하여 두 개의 Concept을 결합할 수 있습니다.

이제 이 Concept을 사용하여 함수 템플릿을 정의할 수 있습니다:

template<AddableAndComparable T>
T max(T a, T b) {
    return a < b ? b : a;
}

max 함수는 AddableAndComparable Concept을 충족하는 타입만 받습니다. 즉, T는 + 연산과 < 연산을 모두 지원해야 하며, 이를 통해 더욱 엄격하고 세밀한 타입 제약을 할 수 있습니다.

복합적인 조건을 결합하여 코드에서 더욱 정확한 타입 체크를 할 수 있기 때문에, 실수나 오류를 예방하는 데 큰 도움이 됩니다.
Concepts를 사용하면 템플릿에서 타입 제약이 불만족할 경우, 컴파일러가 제공하는 오류 메시지가 훨씬 더 직관적이고 이해하기 쉬워집니다. 기존의 SFINAE나 enable_if 방식으로 타입 제약을 구현할 경우, 오류 메시지가 모호하거나 복잡하게 출력될 수 있지만, Concepts는 구체적인 제약을 명확히 해주기 때문에 발생하는 오류를 쉽게 파악할 수 있습니다.

예를 들어, Addable Concept을 사용한 함수 템플릿에서 + 연산이 불가능한 타입을 전달하면, 컴파일러는 다음과 같은 구체적인 오류 메시지를 제공합니다:

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

std::vector<int>와 같이 + 연산을 지원하지 않는 타입을 넘기면, 다음과 같은 오류가 발생할 수 있습니다:

error: no matching function for call to ‘add(std::vector<int>, std::vector<int>)’
note: candidate: template<Addable T> T add(T, T) 
note:   constraint ‘Addable<T>’ is not satisfied
note:   because ‘std::vector<int>’ does not satisfy ‘Addable’

위 오류 메시지는 Addable Concept을 만족하지 않아서 std::vector<int> 타입이 + 연산을 지원하지 않는다는 점을 명확히 알려줍니다. 기존의 SFINAE 방식에서는 이런 오류가 다소 추상적으로 나타날 수 있었기 때문에, Concepts를 사용하면 문제를 빠르게 식별하고 해결할 수 있습니다.

이러한 직관적인 오류 메시지는 코드 작성 중 타입 오류를 빠르게 수정하는 데 큰 도움이 됩니다.
C++에서 Concepts는 기존의 SFINAE(Substitution Failure Is Not An Error) 방식과 비교했을 때, 훨씬 더 직관적이고 명확한 타입 제약을 제공합니다. SFINAE는 템플릿 인수에 맞지 않는 타입이 있을 때 컴파일러가 오류를 발생시키는 대신, 이를 무시하거나 다른 경로를 시도하는 특성 덕분에 코드가 복잡해지고, 오류 메시지가 명확하지 않을 수 있습니다. 반면, Concepts는 제약 조건을 명확하게 정의하고, 이를 만족하지 않는 타입에 대해 구체적인 오류 메시지를 제공하여 디버깅을 쉽게 만듭니다.

예를 들어, SFINAE를 사용할 때 다음과 같은 코드가 있을 수 있습니다:

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

template<typename T>
T add(T a, T b, typename std::enable_if<!std::is_integral<T>::value>::type* = nullptr) {
    return a + b; // non-integral types only
}

위 코드에서, enable_if와 std::is_integral을 사용하여 T가 정수 타입이 아닐 때만 특정 함수를 활성화합니다. 만약 정수 타입이 전달되면, 해당 함수는 선택되지 않고 다른 함수가 호출됩니다. 그러나 오류가 발생했을 때, enable_if와 관련된 오류 메시지는 매우 추상적이고 해석하기 어려울 수 있습니다.

반면, Concepts를 사용하면 코드가 더 직관적이고 오류 메시지가 구체적입니다. 아래는 같은 기능을 Concepts로 구현한 예시입니다:

template<typename T>
concept NotIntegral = !std::is_integral_v<T>;

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

이 코드에서 NotIntegral Concept은 T가 정수 타입이 아닌 경우에만 add 함수를 활성화합니다. 만약 정수 타입을 전달하면, 컴파일러는 다음과 같은 오류 메시지를 제공합니다:

error: ‘int’ does not satisfy ‘NotIntegral’

이처럼 Concepts를 사용하면 코드가 간결하고, 오류 메시지도 훨씬 이해하기 쉬워집니다. Concepts는 타입 제약을 명확히 정의하는 방식으로, SFINAE 방식보다 더 직관적이고 가독성이 높은 코드를 작성하는 데 도움이 됩니다.
Concepts는 매우 유용한 기능이지만, 이를 사용할 때 몇 가지 고려할 사항이 있습니다. 특히, C++20 이전 버전의 컴파일러에서는 Concepts를 사용할 수 없기 때문에, Concepts를 활용하려면 C++20을 지원하는 컴파일러를 사용해야 합니다. 또한, Concepts를 적절히 활용하기 위해서는 타입 제약을 잘 정의하는 것이 중요합니다.

  1. 컴파일러 지원
    Concepts는 C++20에서 새롭게 도입된 기능이므로, 이를 사용하려면 C++20을 지원하는 컴파일러가 필요합니다. 예를 들어, GCC 10 이상, Clang 10 이상, MSVC 2019 버전에서 지원합니다. 따라서 프로젝트에서 Concepts를 사용하려면 사용 중인 컴파일러가 이를 지원하는지 확인해야 합니다. 만약 이전 버전의 컴파일러를 사용한다면, Concepts를 사용할 수 없으므로 다른 방법으로 타입 제약을 구현해야 합니다.
  2. 타입 제약 정의의 정확성
    Concepts를 사용할 때 중요한 점은 제약을 정확하고 명확하게 정의하는 것입니다. 잘못된 제약 조건을 설정하면, 코드가 의도한 대로 동작하지 않거나, 불필요하게 복잡한 조건을 사용하게 될 수 있습니다. 예를 들어, 불필요하게 여러 조건을 결합하거나, 너무 많은 타입에 대해 제약을 적용하면 코드가 과도하게 복잡해질 수 있습니다. 가능한 경우, 제약을 간결하고 직관적으로 작성하는 것이 좋습니다.
  3. 호환성
    Concepts는 기존 코드와의 호환성에 영향을 미칠 수 있습니다. 기존의 SFINAE나 enable_if 방식으로 작성된 코드와 함께 사용할 때, Concepts를 추가하는 것이 문제를 일으킬 수 있습니다. 예를 들어, SFINAE를 사용한 템플릿 함수가 이미 존재할 경우, Concepts와 혼합하여 사용하는 것에 대한 주의가 필요합니다. 코드의 호환성을 유지하려면 두 방식을 혼합해서 사용하는 대신, 하나의 방식에 집중하는 것이 좋습니다.
  4. 컴파일 시간
    Concepts를 사용하면 컴파일 타임에 타입을 더 엄격히 검사할 수 있기 때문에, 코드의 오류를 사전에 잡을 수 있는 장점이 있지만, 컴파일 시간이 길어질 수 있습니다. 복잡한 제약 조건이나 많은 Concept을 사용하면, 컴파일러가 이를 처리하는 데 더 많은 시간이 걸릴 수 있습니다. 따라서 성능에 민감한 프로젝트에서는 Concepts를 사용할 때 이 점을 고려해야 합니다.
  5. 타입 추론 문제
    Concept을 사용한 템플릿 함수에서 타입 추론이 제대로 이루어지지 않는 경우가 있을 수 있습니다. 특히, auto를 사용한 템플릿에서 Concept을 적용할 때, 타입 추론이 제대로 작동하지 않거나, 예상하지 못한 오류가 발생할 수 있습니다. 이 경우, 명시적인 타입을 지정하거나, 제약 조건을 더욱 명확히 정의하는 방식으로 해결할 수 있습니다.

이러한 고려사항들을 염두에 두고 Concepts를 적절히 사용하면, C++20에서 더욱 안전하고 읽기 쉬운 코드를 작성할 수 있습니다.
C++20에서 Concepts는 템플릿 메타프로그래밍을 보다 효율적이고 직관적으로 만들어주는 강력한 도구입니다. 다양한 상황에서 Concepts를 어떻게 활용할 수 있는지 몇 가지 응용 예시를 살펴보겠습니다.

예시 1: 기본적인 타입 제약

먼저, Addable Concept을 활용하여 더하기 연산을 지원하는 타입만 받는 함수 템플릿을 작성할 수 있습니다. 이는 타입 제약을 통해 컴파일 타임에 오류를 사전에 잡을 수 있게 해줍니다.

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

이 함수는 + 연산을 지원하는 타입만을 허용하며, 만약 std::vector와 같은 더하기 연산이 불가능한 타입이 전달되면 컴파일러에서 오류가 발생합니다.

예시 2: 여러 Concept 결합

Addable Concept과 Comparable Concept을 결합하여, 더하기 연산과 비교 연산을 모두 지원하는 타입만 허용하는 함수를 작성할 수 있습니다. 이와 같은 방식으로 복합적인 조건을 적용하여 더욱 강력한 제약을 만들 수 있습니다.

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

template<typename T>
concept AddableAndComparable = Addable<T> && Comparable<T>;

template<AddableAndComparable T>
T max(T a, T b) {
    return a < b ? b : a;
}

위 예제에서 max 함수는 + 연산과 < 연산을 모두 지원하는 타입만 허용합니다.

예시 3: 사용자 정의 Concept 사용

C++20에서는 사용자가 자신만의 Concept을 정의할 수 있습니다. 예를 들어, 특정 타입이 std::vector와 같은 컨테이너 타입인지 확인하는 Concept을 작성할 수 있습니다.

template<typename T>
concept Container = requires(T a) {
    typename T::value_type;
    { a.begin() } -> std::input_iterator;
    { a.end() } -> std::input_iterator;
};

template<Container T>
void printContainer(const T& container) {
    for (const auto& elem : container) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;
}

이 함수는 std::vector, std::list와 같은 컨테이너 타입에 대해서만 호출할 수 있으며, 사용자가 정의한 제약을 통해 컨테이너 타입에 대한 특정 조건을 만족하는지 확인할 수 있습니다.

예시 4: 템플릿 메타프로그래밍에서의 활용

Concepts는 템플릿 메타프로그래밍을 할 때도 매우 유용합니다. 예를 들어, 템플릿 특수화를 보다 쉽게 다룰 수 있게 도와줍니다.

template<typename T>
concept Integral = std::is_integral_v<T>;

template<Integral T>
void printIntegral(T value) {
    std::cout << value << " is an integral type." << std::endl;
}

template<typename T>
void printIntegral(T value) {
    std::cout << value << " is not an integral type." << std::endl;
}

이 예시에서는 Integral Concept을 사용하여 정수형 타입만 처리하는 특수화된 함수를 작성하고, 그 외의 타입에 대해서는 기본 함수를 제공하는 방식으로, 타입에 따라 다른 동작을 하도록 할 수 있습니다.

예시 5: 타입 변환 제약

Concepts는 또한 타입 변환이 가능해야 하는 제약을 설정하는 데 유용합니다. 예를 들어, 특정 타입이 std::string으로 변환할 수 있는지 확인하는 Concept을 만들 수 있습니다.

template<typename T>
concept ConvertibleToString = requires(T a) {
    { std::to_string(a) } -> std::same_as<std::string>;
};

template<ConvertibleToString T>
void printAsString(T value) {
    std::cout << std::to_string(value) << std::endl;
}

위 함수는 std::to_string으로 변환할 수 있는 타입에 대해서만 동작하며, 해당 타입이 변환이 불가능할 경우 컴파일 타임에 오류가 발생합니다.

Concepts는 이렇게 다양한 방식으로 타입 제약을 명확하고 직관적으로 표현할 수 있게 해 줍니다. 이를 활용하면 코드의 안전성을 높이고, 컴파일 타임에 발생할 수 있는 오류를 사전에 방지할 수 있어 더 신뢰성 높은 코드를 작성할 수 있습니다.

목차
  1. 요약

요약


C++20에서 도입된 Concepts는 템플릿 메타프로그래밍을 보다 직관적이고 명확하게 만들어주는 강력한 도구입니다. 이를 사용하면 함수 템플릿에서 타입 제약을 명확히 정의할 수 있으며, 컴파일 타임에 발생하는 오류를 직관적으로 파악할 수 있습니다. Concepts는 기존의 enable_if와 같은 SFINAE 기법보다 훨씬 간결하고 이해하기 쉬운 코드 작성이 가능하게 해줍니다.

Concepts를 활용하면:

  • 템플릿 함수에서 타입에 대한 제약을 명확하게 설정할 수 있습니다.
  • Addable, Comparable 등의 사용자 정의 Concept을 활용하여 더 강력한 타입 제약을 적용할 수 있습니다.
  • 타입을 제약하여 컴파일 타임에 오류를 쉽게 확인하고, 디버깅 시간을 절감할 수 있습니다.

따라서 Concepts는 C++20에서 코드의 안전성을 높이고, 템플릿 메타프로그래밍을 효율적으로 작성할 수 있도록 돕는 중요한 기능입니다.

C++
C++ C++20 Concepts 타입 제약
목차
  1. 요약