コンセプトを関数に渡す

概念はコンパイル時の述語として定義されているため、これらの述語をコンパイル時のアルゴリズムに実際に再利用することもできますか？たとえば、タプルのすべての型がコンセプトに準拠しているかどうかを確認することは可能でしょうか？私が見た限りでは、概念を関数に渡すことは決して不可能であり、そのため、これらの場合にテンプレートを使用することに戻ってきました。

#include <type_traits>

template<typename T>
concept FloatLike = std::is_same_v<T, float>;

struct IsFloat
{
    template<typename U>
    constexpr static bool test()
    {
       return FloatLike<U>;
    }
};


template<typename Predicate, typename... T>
constexpr bool all_types()
{
    return (Predicate::template test<T>() && ...);
}


int main()
{
   static_assert(all_types<IsFloat, float, float>());
   static_assert(!all_types<IsFloat, float, int>());
}

私がやりたいのは次のようなものなので、それを使用できるようにするために常にコンセプトをラップする必要はありません。

template<concept Predicate, typename... T>
constexpr bool all_types()
{
    return (Predicate<T> && ...);
}


int main()
{
   static_assert(all_types<FloatLike, float, float>());
   static_assert(!all_types<FloatLike, float, int>());
}

これに近づく方法はありますか？

これに近づく方法はありますか？

まあ、いや、そうでもない。C ++ 20にはありません。今日の言語では、テンプレートコンセプトパラメータの概念はありません。変数テンプレートでさえ、テンプレートパラメータとして使用できません。したがって、最初にコンセプトがある場合、ラッピングを回避することはできません。

しかし、私たちにできることは、より単純なラッパーを書くことです。「古いスタイル」タイプの特性を述語として使用することに同意する場合、特にstd::integral_constantsのように動作する特性は、述語として使用できるかなり簡潔な「概念」定義を持つことができます。

template<typename T>
using FloatLike = std::is_same<T, float>;

template<template <typename> class Predicate, typename... T>
constexpr bool all_types()
{
    return (Predicate<T>{} && ...);
}

私が見る限り、それはできる限り良いです。

「タプル内のすべての型がコンセプトに準拠しているかどうかを確認する」ことが目標である場合は、次のようなことができます。

// concept to check if all types in Ts are the same as T
template<typename T, typename... Ts>
concept AllSame = (std::is_same_v<T,Ts> && ...);

// function only accepts floats as template parameters
template<AllSame<float>... Floats>
constexpr void float_foo()
{
}

// function only accepts ints as template parameters
template<AllSame<int>... Ints>
constexpr void int_foo()
{
}

// function only accepts T as template parameters
template<typename T, AllSame<T>... Ts>
constexpr void foo()
{
}

int main()
{
    int_foo<int, int, int>();
    // int_foo<int, int, double>(); // fails to compile
    float_foo<float, float, float>();
    // float_foo<float, float, int>(); // fails to compile
    foo<int, int, int, int>();
    // foo<int, int, int, float>(); // fails to compile
    foo<double, double, double, double>();
    // foo<double, double, double, int>(); // fails to compile

}

ライブデモ