Ein Konzept an eine Funktion übergeben

Ist es auch möglich, diese Prädikate für Algorithmen zur Kompilierungszeit wiederzuverwenden, da Konzepte als Prädikate zur Kompilierungszeit definiert sind? Wäre es beispielsweise möglich zu überprüfen, ob alle Typen in einem Tupel einem Konzept entsprechen? Soweit ich gesehen habe, ist es nicht möglich, ein Konzept in irgendeiner Weise an eine Funktion zu übergeben, was mich zurückführt, Vorlagen für diese Fälle zu verwenden.

#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>());
}

Was ich gerne machen würde, ist so etwas, also muss ich das Konzept nicht die ganze Zeit einpacken, um es verwenden zu können:

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

Gibt es eine Möglichkeit, dem näher zu kommen?

Gibt es eine Möglichkeit, dem näher zu kommen?

Nein, nicht wirklich. Nicht in C ++ 20. In der heutigen Sprache gibt es keinen Begriff für einen Vorlagenkonzeptparameter. Auch variable Vorlagen können nicht als Vorlagenparameter verwendet werden. Wenn Sie also zunächst ein Konzept haben, können wir das Umwickeln nicht vermeiden.

Wir können jedoch einfachere Wrapper schreiben. Wenn wir uns damit einverstanden erklären, Merkmale vom Typ "alter Stil" als Prädikate zu verwenden, insbesondere solche, die sich wie std::integral_constants verhalten , können wir ziemlich knappe "Konzept" -Definitionen haben, die als Prädikate verwendet werden können.

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

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

Es ist so gut wie es nur geht , soweit ich sehen kann.

Wenn Ihr Ziel darin besteht, "zu überprüfen, ob alle Typen in einem Tupel einem Konzept entsprechen" , können Sie Folgendes tun:

// 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

}

LIVE DEMO