Концепции C ++: проверка экземпляра шаблона

Используя вывод аргументов шаблона класса C ++ 17, вы сможете сделать что-то вроде этого:

template<typename A, typename B, typename C>
struct mytype { };

template<class T>
concept C1 = requires(T x) { 
    { mytype{x} } -> std::same_as<T>;
};

mytype{x} использует вывод аргументов шаблона класса для вывода A, B и C, так что это допустимо, если вы можете построить mytype<A, B, C> из T. В частности, это действительно, если mytype может быть сконструирован путем копирования, поскольку у вас есть неявно объявленный руководство по копированию, похожее на:

template <typename A, typename B, typename C>
mytype(mytype<A, B, C>) -> mytype<A, B, C>;

Проверяя, что T также является созданным экземпляром mytype, избегайте сопоставления с другими руководствами по дедукции, например, это будет соответствовать любому типу без -> std::same_as<T>:

template <class A, class B, class C>
struct mytype {
    mytype(A);
};

template <class A>
mytype(A) -> mytype<A, A, A>;

Предлагаемое решение не работает для классов, не поддерживающих копирование, хотя должно быть возможно заставить его работать для классов, предназначенных только для перемещения.

Протестировано с:

• clang реализация экспериментальных концепций: https://godbolt.org/z/iwztWK
• gcc текущая реализация (не соответствует стандарту): https://godbolt.org/z/I4Ax7k

Для этой цели вы можете определить свою собственную мета-функцию (признак типа):

template <typename T>
struct is_mytype : std::false_type { };

template <typename A, typename B, typename C>
struct is_mytype<mytype<A, B, C>> : std::true_type { };

template <typename T>
concept MyType = is_mytype<T>::value;

Но, честно говоря, я не знаю, нет ли способа, как определить такую ​​концепцию напрямую, без необходимости в отдельной метафункции.

Вы можете написать обобщенный признак для проверки специализаций:

template <typename T, template <typename...> class Z>
struct is_specialization_of : std::false_type {};

template <typename... Args, template <typename...> class Z>
struct is_specialization_of<Z<Args...>, Z> : std::true_type {};

template <typename T, template <typename...> class Z>
inline constexpr bool is_specialization_of_v = is_specialization_of<T,Z>::value;

Что вы можете превратить в обобщенную концепцию:

template<typename T, template <typename...> class Z>
concept Specializes = is_specialization_of_v<T, Z>;

template<typename T>
concept MyType = Specializes<T, mytype>;

или просто специализированный:

template<typename T>
concept MyType = is_specialization_of_v<T, mytype>;

В интересах краткости:

template<typename T>
concept MyType = requires(T** x) {
    []<typename A, typename B, typename C>(mytype<A, B, C>**){}(x);
};

Двойной указатель необходим, чтобы избежать преобразований производных в базовые, например. struct S : mytype<int, int, int> {}.

В настоящее время это не работает в clang, поскольку не позволяет использовать лямбды в неоцененном контексте. Вы можете обойти эту проблему, предоставив шаблон вспомогательной переменной:

template<class T> constexpr auto L = []<typename A, typename B, typename C>(mytype<A, B, C>**){};
template<typename T>
concept MyType = requires(T** x) { L<T>(x); };

Пока аргументы шаблона mytype являются всеми типами, вы можете сделать это еще более кратким, используя заполнители:

template<typename T>
concept MyType = requires(T** x) { [](mytype<auto, auto, auto>**){}(x); };

В настоящее время это работает только в gcc.

Если вы наделили свой шаблонный класс некоторыми чертами, вы можете сделать следующее:

template<typename A, typename B, typename C>
struct mytype {
    using a_type = A;
    using b_type = B;
    using c_type = C;
};

С ассоциированной концепцией:

template <typename T>
concept is_mytype =
    std::is_same_v<
        std::remove_const_t<T>,
        mytype<typename T::a_type, typename T::b_type, typename T::c_type>>;

Или, если у mytype есть члены этих типов, вы можете пропустить черты:

template<typename A, typename B, typename C>
struct mytype {
    A a_inst;
    B b_inst;
    C c_inst;
};

Придание концепции:

template <typename T>
concept is_mytype =
    std::is_same_v<
        std::remove_const_t<T>,
        mytype<decltype(T::a_inst), decltype(T::b_inst), decltype(T::c_inst)>>;