Bir kavramın bir işleve aktarılması

Kavramlar derleme zamanı tahminleri olarak tanımlandığından, bu tahminleri derleme zamanı algoritmaları için yeniden kullanmak da mümkün müdür? Örneğin, bir demet içindeki tüm tiplerin bir konsepte uygun olup olmadığını kontrol etmek mümkün müdür? Gördüğüm kadarıyla, bir kavramı bir işleve herhangi bir şekilde aktarmak mümkün değil, bu da beni bu durumlar için şablonlar kullanmaya geri götürüyor.

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

Ne yapmak istiyorum böyle bir şey, bu yüzden kullanmak için her zaman kavramı sarmak zorunda değilim:

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

Buna yaklaşmanın bir yolu var mı?

Buna yaklaşmanın bir yolu var mı?

Şey, hayır, pek değil. C ++ 20'de değil. Günümüzde, bir dil kavramı-parametresi ile ilgili bir kavram yoktur. Değişken şablonlar bile şablon parametresi olarak kullanılamaz. Bu nedenle, bir konseptiniz varsa, sarmaktan kaçınamayız.

Ama yapabileceğimiz daha basit ambalajlar yazmak. Eğer "eski stil" tipi özellikleri tahmin olarak, özellikle std::integral_constants gibi davrananları kullanmayı kabul edersek, kendimizi tahmin olarak kullanılabilecek oldukça kısa "konsept" tanımlarına sahip olabiliriz.

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

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

Sanki iyi olarak var alabileceği bildiğim kadarıyla gördüğünüz gibi.

Hedefiniz "bir gruptaki tüm türlerin bir konsepte uygun olup olmadığını kontrol etmek" ise , bunun gibi bir şey yapabilirsiniz:

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

}

CANLI DEMO