实现开关类型特征（使用 std::conditional_t 链调用）

Question

这就是我想要的，一个 "switch" 类型特征 returns 第一个具有条件 == 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);
}

如您所见，它在编译时根据传递的 conditions/types 决定我想要哪种分布。

显然，如果我尝试添加更多条件，这会很快变得非常丑陋，假设我想要其中的 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;

我尝试制作 cond 结构的原因是我可以获得 "pairs" 的 conditions/types，所以我可以使用可变参数模板获得任意数量的那些，但这使得它更加丑陋（并且不工作）：

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

不仅它看起来不像我想要的最终版本那么好，而且它甚至不起作用！它仅在第一个条件为真时有效..

我有什么遗漏吗？还有我怎样才能以更干净的方式实现这一点（至少对于最终用户而言）。

提前致谢。

Answer 1

问题出在您的基本案例中：

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

现在这有点低效，因为您必须在顶部处理整个条件。为此，您可以编写一个单独的元函数，Boost.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中，放在你自己的命名空间中。

实现开关类型特征（使用 std::conditional_t 链调用）

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

c++

templates

typetraits