Question

这就是我想要的，一个＆＃34;开关＆＃34; type trait返回第一个具有condition == 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;

我试图制作cond结构的原因是我可以得到＆＃34;对＆＃34;条件/类型，所以我可以使用可变参数模板获得任意数量，但这使它更加丑陋（并且不工作）：

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...>>
{ };

此外，通常我们只会有一个＆＃34; else＆＃34;最后的情况，所以也许你可以把你的选择器写成：

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中，将其放在您自己的命名空间中。

实现switch类型trait（使用std :: conditional_t链调用）

1 个答案: