C++: concepts

개요

• Named sets of such requirements
  • 이름을 가진 요구사항의 집합
  • 타입이 가져야 하는 요구사항을 정의하는 문법
• 제약 조건을 지정
  • 템플릿 인자
  • 변수 선언
• 제약 조건은 컴파일 타임에 평가
• 함수 오버로딩이나 템플릿 특수화에서 가장 적절한 함수를 선택하는데 사용
• 기존에는 템플릿 인자의 타입에만 의존하여 함수 오버로딩 가능
• concept은 타입뿐만 아니라 속성 혹은 연산자에 따라 함수 오버로딩 가능
• 런타임에 수행하던 논리 연산들이 컴파일 타임에 결정되어 에러 검출 시점 앞당김 및 실행 속도 향상
• 컴파일 에러 가동성 증가

concept

• 문법
  • 정의

    template < template-parameter-list >
    concept concept-name = constraint-expression;

• 사용
  • requires clause
    • 템플릿 선언 뒤에 requires 선언
    • template <typename T> requires over4<T>
  • constrained type template parameter
    • 템플릿 인자에 선언
    • template auto func(T t) {}
  • abbreviated function template declaration
    • 파라미터에 선언
    • auto func(over4 auto t) {}
  • trailing requires clause
    • 함수 선언 뒤에 requires 선언
  • template <typename T> auto func(T t) requires over4<T> {}
• concepts library
• 예제
  • 코드

        #include <concepts>
        #include <iostream>
        #include <string>
        #include <type_traits>

        using namespace std;

        template <typename T>
        concept over4 = sizeof(T) >= 4;

        template <typename T>
        requires over4<T>
        auto howToUseConcept_1(T t) { cout << "over4" << endl; }

        template <typename T> auto howToUseConcept_1(T t) {
            cout << "not over4" << endl;
        }

        template <over4 T> auto howToUseConcept_2(T t) {}

        auto howToUseConcept_3(over4 auto t) {}

        template <typename T> auto howToUseConcept_4(T t) requires over4<T> {}

        template <class T>
        concept integeral = is_integral<T>::value;

        int main() {
            howToUseConcept_1(int());
            howToUseConcept_1(short());

            cout << integral<int> << endl;
            cout << integral<string> << endl;

            auto i1 = int(1);
            over4 auto i2 = int(2);
            // over4 i3 = short();
            cout << i1 << endl;
            cout << i2 << endl;

            return 0;
        }

• 실행 결과

        over4
        not over4
        1
        0
        1
        2

requires clauses

• 문법

    template<typename T>
    void f(T&&) requires Eq<T>;

• requires 뒤에는 상수 표현식이여야함
• 예제
  • 코드

        #include <concepts>

        using namespace std;

        template <typename T>
        concept over4 = sizeof(T) >= 4;

        template <typename T>
        requires over4<T>
        void func(T t) {}

        template <typename T>
        requires(sizeof(T) >= 4) void func(T t) {}

        template <typename T>
        requires true void func(T t) {}

        template <typename T>
        requires false void func(T t) {}

        template <typename T>
        requires is_pointer<T>::value void func(T t) {}

        constexpr bool check() { return true; }
        template <typename T>
        requires(check()) void func(T t) {}

        template <typename T>
        requires is_pointer<T>::value &&(check()) void func(T t) {}

        int main() { return 0; }

requires expression

• 문법

    requires { requirement-seq }

    requires ( parameter-list(optional) ) { requirement-seq }

• 예제
  • 코드

        #include <concepts>
        #include <iterator>
        #include <vector>

        using namespace std;

        template <typename T>
        concept concept_1 = requires {
            typename T::iterator;
        };
        template <concept_1 T> void func1(T t) {}

        template <typename T>
        concept concept_2 = requires(T t) {
            t.size();
        };
        template <concept_2 T> void func2(T t) {}

        template <typename T>
        concept concept_3 = requires(T t) {
            t.size();
            t.begin();
            t.end();
        };
        template <concept_3 T> void func3(T t) {}

        template <typename T>
        concept concept_4 = requires(T t1, T t2) {
            t1 < t2;
            t1 == t2;
            t1 > t2;
        };
        template <concept_4 T> void func4(T t1, T t2) {}

        template <typename T1, typename T2>
        concept concept_5 = requires(T1 t1, T2 t2) {
            t1.size();

            t2.begin();
            t2.end();
        };
        template <typename T1, typename T2>
        requires concept_5<T1, T2>
        void func5(T1 t1, T2 t2) {}

        class Test {
            public:
                int size() { return 0; }
        };

        int main() {
            // func1(int());
            func1(vector<int>{});

            // func2(int());
            func2(Test());
            func2(vector<int>{});

            // func3(Test());
            func3(vector<int>{});

            func4(1, 2);
            func4("a", "b");
            // func4(1, "1");

            func5(Test(), vector<int>{});
            // func5(vector<int>{}, Test());

            return 0;
        }