实现一个开关类型trait(使用std::conditional_t链调用)

implementing a switch type trait (with std::conditional_t chain calls)

本文关键字：conditional std 调用 trait 一个 开关 实现 类型 使用      更新时间：2023-10-16

这就是我想要的，一个"switch"类型的trait，返回第一个具有条件== true的类型:

ext::select_t<condition1 == true, Type1,
              condition2 == true, type2,
              condition3 == true, type3>

等，并且可以添加任意多的条件/类型对。

我可以这样做std::conditional(随机示例):

template<typename Number,
         typename Distribution = std::conditional_t<
                 // IF
                 std::is_integral<Number>::value,
                 // RETURN INT
                 std::uniform_int_distribution<Number>,
                 // ELSE
                 std::conditional_t<std::is_floating_point<Number>::value,
                                    // RETURN REAL
                                   std::uniform_real_distribution<Number>, void>>>
Number random(Number min, Number max)
{
    static std::random_device rd;
    static std::mt19937 mt(rd());
    Distribution dist(min, max);
    return dist(mt);
}

正如你所看到的，它在编译时根据传递的条件/类型决定我想要什么样的发行版。

显然，如果我试图添加更多条件，这会很快变得非常难看，想象一下我想要10个条件。

所以我试着建立一个，但失败了:

template<bool B, typename T>
struct cond
{
    static constexpr bool value = B;
    using type = T;
};
template<typename Head, typename... Tail>
struct select
{
    using type = std::conditional_t<Head::value, typename Head::type, select<Tail...>>;
};
template<typename Head>
struct select<Head>
{
    using type = std::conditional_t<Head::value, typename Head::type, void>;
};
template<typename Head, typename... Tail>
using select_t = typename select<Head, Tail...>::type;

我尝试创建第二个结构的原因是这样我就可以获得条件/类型的"对"，所以我可以使用可变模板获得任何数量的条件/类型，但这使得它更难看(而且不起作用):

using Type = std::select_t<cond<false, void>,
                           cond<false, int>,
                           cond<true, std::string>>;

不仅看起来没有我想要的最终版本好，而且它甚至不能工作!它只在第一个条件为真时起作用。

我错过什么了吗?还有，我怎样才能以一种更干净的方式实现这一点(至少对最终用户来说)。

问题在于您的基本情况:

using type = std::conditional_t<Head::value, typename Head::type, select<Tail...>>;

您希望在成功(Head::value)时使用头部类型(Head::type)，但在失败时使用尾部类型。但select<Tail...>不是尾部类型。这是一个元函数。你需要对它进行计算:

using type = std::conditional_t<
                 Head::value, 
                 typename Head::type,
                 typename select<Tail...>::type>;

现在，这有点低效，因为您必须在顶部处理整个条件。为此，您可以编写一个单独的元函数。MPL打电话给eval_if。它不是接受一个布尔值和两个类型，而是接受一个布尔值和两个元函数:

template <bool B, typename TrueF, typename FalseF>
struct eval_if {
    using type = typename TrueF::type;
};
template <typename TrueF, typename FalseF>
struct eval_if<false, TrueF, FalseF> {
    using type = typename FalseF::type;
};    
template <bool B, typename T, typename F>
using eval_if_t = typename eval_if<B, T, F>::type;

使select的主用例变为:

template<typename Head, typename... Tail>
struct select
{
    using type = eval_if_t<Head::value,
                           Head,
                           select<Tail...>>;
};

虽然在反射上，同样可以用std::conditional_t和继承来完成:

template <typename Head, typename... Tail>
struct select
: std::conditional_t<Head::value, Head, select<Tail...>>
{ };

另外，通常我们会在最后有一个"else"的情况，所以也许你会把你的选择器写为:

using T = select_t<cond<C1, int>,
                   cond<C2, float>,
                   double>;

所以我建议这样写你的基本情况:

template <typename T>
struct select<T>
{
    using type = T;
};
template <bool B, typename T>
struct select<cond<B, T>>
{
    // last one had better be true!
    static_assert(B, "!");
    using type = T;
};

还有，你写了std::select_t…不要把它放在名称空间std中，把它放在您自己的名称空间中。

相关文章：