Question

    template<class _Other1,
    class _Other2,
    class = enable_if_t<is_constructible<_Ty1, _Other1>::value
                    && is_constructible<_Ty2, _Other2>::value>,
    enable_if_t<is_convertible<_Other1, _Ty1>::value
            && is_convertible<_Other2, _Ty2>::value, int> = 0>
    constexpr pair(pair<_Other1, _Other2>&& _Right)
        _NOEXCEPT_OP((is_nothrow_constructible<_Ty1, _Other1>::value
            && is_nothrow_constructible<_Ty2, _Other2>::value))
    : first(_STD forward<_Other1>(_Right.first)),
        second(_STD forward<_Other2>(_Right.second))
    {   // construct from moved compatible pair
    }

template<class _Other1,
    class _Other2,
    class = enable_if_t<is_constructible<_Ty1, _Other1>::value
                    && is_constructible<_Ty2, _Other2>::value>,
    enable_if_t<!is_convertible<_Other1, _Ty1>::value
            || !is_convertible<_Other2, _Ty2>::value, int> = 0>
    constexpr explicit pair(pair<_Other1, _Other2>&& _Right)
        _NOEXCEPT_OP((is_nothrow_constructible<_Ty1, _Other1>::value
            && is_nothrow_constructible<_Ty2, _Other2>::value))
    : first(_STD forward<_Other1>(_Right.first)),
        second(_STD forward<_Other2>(_Right.second))
    {   // construct from moved compatible pair
    }

VS 2017第206行的

实用程序文件， _Other1和_Other2是参数，这是 std :: pair 的构造函数，我们正在使用Other1和Other2来初始化“first”和“second”，

我认为 is_constructible 就足够了，为什么我们在这里使用 is_convertible ？
顺便说一下，class = enable_if_t< ... ::value>和enable_if_t< ... ::value,int> = 0之间有什么区别？

Answer 1

我认为is_constructible已经足够了，为什么我们在这里使用is_convertible？

这里的目标是正确处理explicit构造。考虑只做前者并尝试编写一个包装器（在这里使用REQUIRES来隐藏你想要的任何SFINAE方法）：

template <class T>
class wrapper {
public:
    template <class U, REQUIRES(std::is_constructible<T, U&&>::value)>
    wrapper(U&& u) : val(std::forward<U>(u)) { }
private:
    T val;
};

如果这就是我们所拥有的，那么：

struct Imp { Imp(int ); };
struct Exp { explicit Exp(int ); };

Imp i = 0; // ok
Exp e = 0; // error
wrapper<Imp> wi = 0; // ok
wrapper<Exp> we = 0; // ok?!?

我们绝对不希望最后一个没问题 - 这打破了对Exp的期望！

现在，s_constructible<T, U&&>如果可以从T直接初始化U&& - 如果T(std::declval<U&&>())是有效表达式，则为真。

另一方面，

is_convertible<U&&, T>检查是否可以从T 复制 - 初始化U&&。也就是说，如果T copy() { return std::declval<U&&>(); }有效。

不同之处在于，如果转化为explicit，则后者不起作用：

+-----+--------------------------+------------------------+
|     | is_constructible<T, int> | is_convertible<int, T> |
+-----+--------------------------+------------------------+
| Imp |        true_type         |       true_type        |
| Exp |        true_type         |       false_type       |
+-----+--------------------------+------------------------+

为了正确传播显性，我们需要同时使用两个特征 - 我们可以用它们创建元特征：

template <class T, class From>
using is_explicitly_constructible = std::integral_constant<bool,
    std::is_constructible<T, From>::value &&
    !std::is_convertible<From, T>::value>;

template <class T, class From>
using is_implicitly_constructible = std::integral_constant<bool,
    std::is_constructible<T, From>::value &&
    std::is_convertible<From, T>::value>;

这两个特征是不相交的，所以我们可以编写两个绝对不可行的构造函数模板，其中一个构造函数是显式的而另一个不是：

template <class T>
class wrapper {
public:
    template <class U, REQUIRES(is_explicitly_constructible<T, U&&>::value)>
    explicit wrapper(U&& u) : val(std::forward<U>(u)) { }

    template <class U, REQUIRES(is_implicitly_constructible<T, U&&>::value)>
    wrapper(U&& u) : val(std::forward<U>(u)) { }
private:
    T val;
};

这为我们提供了理想的行为：

wrapper<Imp> wi = 0; // okay, calls non-explicit ctor
wrapper<Exp> we = 0; // error
wrapper<Exp> we2(0); // ok

这是实现在这里所做的 - 除了两个元特征之外，它们具有写出explicit的所有条件。

Answer 2

实施[pairs.pair]/12：

除非is_constructible_v<first_type, U1&&>为真，否则此构造函数不应参与重载决策 is_constructible_v<second_type, U2&&>是真的。 当且仅当is_convertible_v<U1&&, first_type>为false或时，构造函数是显式的 is_convertible_v<U2&&, second_type>是假的。

为什么'is_convertible'在<utility> std :: pair（STL）中？

2 个答案: