操作员||STD ::变体的过载

Question

是否有可能对std::variant过载operator||，如果替代类型具有该操作员，并且如果替代方案没有定义此类操作员？

，请使用它吗？

到目前为止，我得到了类似的东西：

template<typename ...Ts>
constexpr bool operator||(std::variant<Ts...> const& lhs, std::variant<Ts...> const& rhs)
{
    return /*no idea */;
}

Answer 1

首先，使用sfinae编写包装器，如果可能

struct Invalid :std::exception { };
struct Call_operator {
    template <typename T, typename U>
    constexpr auto operator()(T&& a, U&& b) const
        noexcept(std::is_nothrow_invocable_v<std::logical_or<>, T, U>)
        -> decltype(static_cast<bool>(std::declval<T>() || std::declval<U>()))
    {
        return std::forward<T>(a) || std::forward<U>(b);
    }
    [[noreturn]] bool operator()(...) const
    {
        throw Invalid{};
    }
};

然后，使用 visit，尊重noexcept：

template <typename T, typename... Ts>
struct is_nothrow_orable_impl
    :std::conjunction<std::is_nothrow_invocable<Call_operator, T, Ts>...> {};
template <typename... Ts>
struct is_nothrow_orable
    :std::conjunction<is_nothrow_orable_impl<Ts, Ts...>...> {};
template<typename ...Ts>
constexpr auto operator||(std::variant<Ts...> const& lhs, std::variant<Ts...> const& rhs)
    noexcept(is_nothrow_orable<Ts...>::value)
    -> decltype(std::visit(Call_operator{}, lhs, rhs))
{
    return std::visit(Call_operator{}, lhs, rhs);
}

(实时演示(

Answer 2

通常人们不建议超载操作员||(或＆amp;＆amp;(当您放松短路评估时。

＆amp;＆amp; ||，并且(逗号(在 超负荷和行为像常规功能呼叫一样，即使它们是 不带功能符号表示法。

另一种方法是定义一个布尔转换操作员，正如我将在此处显示的那样。这需要MyVariant类，而不是直接使用std::variant。因此，此答案不能像问题中那样提供具有确切语法的解决方案。但是，我认为该解决方案也可能很有趣。

从 @l.f的(硬核(答案中启发。我需要一些时间来理解，以下代码使用一个简单的布尔转换操作员和一个类似于 @l.f的Call_constructor。然后可以使用操作员||，&&，...，...

call_operator

struct Call_Operator
{
    template <typename T>
    constexpr auto operator()(T&& a) const
        -> decltype(static_cast<bool>(std::declval<T>()))
    {
        return std::forward<T>(a);
    }
    bool operator()(...) const
    {
        throw std::exception();
    }
};

myVariant

template <typename ... Args>
struct MyVariant : public std::variant<Args...>
{    
    explicit operator bool()
    {
        return std::visit(Call_Operator{}, static_cast<std::variant<Args...>>(*this));
    }
};

用法

int main()
{
    struct C {}; // operator bool not defined -> if (C{}){} does not compile
    MyVariant<bool,int,char> v1 { 1 };
    MyVariant<float,C> v2 { C{} };
    if (v1) {} // no exception, returns true as static_cast<bool>(1) = true
    if (v2) {} // throw exception since an instance of C cannot be converted to bool
    if (v1 || v2) {} // no exception due to lazy evaluation (v2 is not evaluated as v1 returns true)
    if (v2 || v1) {} // throws exception (C cannot be converted to bool)
    if (v1 && v2) {} // throws exception ...
    return 0;
}