Truyền một khái niệm cho một chức năng

Vì các khái niệm được định nghĩa là các vị từ thời gian biên dịch, nên thực tế cũng có thể sử dụng lại các vị từ này cho các thuật toán thời gian biên dịch? Ví dụ, liệu có thể kiểm tra xem tất cả các loại trong một tuple có phù hợp với một khái niệm không? Theo như tôi đã thấy, không thể truyền khái niệm cho hàm theo bất kỳ cách nào, điều này dẫn tôi trở lại sử dụng các mẫu cho các trường hợp này.

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

Những gì tôi muốn làm là một cái gì đó như thế này, vì vậy tôi không phải bao bọc khái niệm này mọi lúc để có thể sử dụng nó:

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ó cách nào để đến gần hơn với điều này?

Có cách nào để đến gần hơn với điều này?

Vâng, không, không thực sự. Không có trong C ++ 20. Ngày nay không có khái niệm nào về ngôn ngữ của một tham số khái niệm mẫu. Ngay cả các mẫu biến cũng không thể được sử dụng làm tham số mẫu. Vì vậy, nếu có một khái niệm để bắt đầu, chúng ta không thể tránh khỏi việc gói.

Nhưng những gì chúng ta có thể làm là viết các hàm bao đơn giản hơn. Nếu chúng ta đồng ý sử dụng các đặc điểm loại "kiểu cũ" làm vị ngữ, cụ thể là các đặc điểm giống như std::integral_constants, thì chúng ta có thể có các định nghĩa "khái niệm" khá ngắn gọn có thể được sử dụng làm vị ngữ.

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

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

Nó tốt như nó có thể nhận được , như tôi có thể thấy.

Nếu mục tiêu của bạn là "kiểm tra xem tất cả các loại trong một tuple có phù hợp với một khái niệm không" , thì bạn có thể làm một cái gì đó như thế này:

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

}

BẢN THỬ TRỰC TIẾP