ผ่านแนวคิดไปยังฟังก์ชั่น

เนื่องจากแนวคิดถูกกำหนดให้เป็นเพรดิเคตเวลาคอมไพล์จึงเป็นไปได้หรือไม่ที่จะใช้เพรดิเคตเหล่านี้ซ้ำสำหรับอัลกอริธึมเวลารวบรวม เช่นเป็นไปได้ไหมที่จะตรวจสอบว่าทุกประเภทใน tuple สอดคล้องกับแนวคิดหรือไม่? เท่าที่ฉันได้เห็นมันเป็นไปไม่ได้ที่จะส่งแนวคิดไปยังฟังก์ชั่นในทางใดทางหนึ่งซึ่งทำให้ฉันกลับไปใช้แม่แบบสำหรับกรณีเหล่านี้

#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 ไม่มีความคิดในภาษาของเทมเพลตแนวคิด - พารามิเตอร์ในวันนี้ แม้แต่เทมเพลตตัวแปรไม่สามารถใช้เป็นพารามิเตอร์เทมเพลตได้ ดังนั้นหากมีแนวคิดที่จะเริ่มต้นด้วยเราไม่สามารถหลีกเลี่ยงการห่อ

แต่สิ่งที่เราทำได้คือเขียน wrappers ที่ง่ายกว่า หากเราเห็นด้วยที่จะใช้ลักษณะ "แบบเก่า" เป็นเพรดิเคตโดยเฉพาะที่มีลักษณะเหมือนstd::integral_constantของ s เราจะมีคำจำกัดความของแนวคิด "แนวคิด" ที่สั้น ๆ ที่สามารถใช้เป็นเพรดิเคตได้

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

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

มันดีเท่าที่จะทำได้เท่าที่ฉันเห็น

หากเป้าหมายของคุณคือ"ตรวจสอบว่าประเภททั้งหมดใน tuple สอดคล้องกับแนวคิด"หรือไม่คุณสามารถทำสิ่งนี้ได้:

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

}

สาธิตสด