Question

根据标准（N4659，§23.2.4，[utility.exchange]），std::exchange应该std::move和std::forward：

template <class T, class U = T> T exchange(T& obj, U&& new_val);

效果：相当于：
T old_val = std::move(obj);
obj = std::forward<U>(new_val);
return old_val;

move和forward都标记为noexcept：
（N4659，§23.2.5，[forward]）：

template <class T> constexpr T&& forward(remove_reference_t<T>& t) noexcept;   template <class T> constexpr T&& forward(remove_reference_t<T>&& t) noexcept;

返回： static_cast<T&&>(t)。

（...）

template <class T> constexpr remove_reference_t<T>&& move(T&& t) noexcept;

返回： static_cast<remove_reference_t<T>&&>(t)。

那么为什么不是exchange noexcept？是否有其他原因或委员会是否忽视了这一点？这是建议还是我可以写一个？

Answer 1

代码也使用构造函数和类型T的赋值运算符。其中一个可能会抛出。

Answer 2

与std::swap不同，noexcept默认情况下仅依赖于移动构造函数，因此通常应为std::exchange，如果需要复制新值，noexcept可能会分配资源。虽然当new_val是U&&时，条件[NSURLSessionConfiguration defaultSessionConfiguration]可能会有一个复杂的表达式，并且移动赋值和旧值的移动都没有抛出，似乎没有人提出这样的建议< / p>

Answer 3

如果您要使用非标准版本来创建noexcept仅使用有条件的noexcept使用rvalues来移动rtor，则可以使用以下版本：

namespace estd {

template<class T, class U = T, std::enable_if_t<
        std::is_move_constructible<std::remove_reference_t<T>>::value && 
        std::is_assignable<std::remove_reference_t<T>, std::remove_reference_t<U>&&>::value && 
        !std::is_lvalue_reference<U>::value,
    int> = 0    
>
T rval_exchange(T& obj, U&& new_value) noexcept(
    std::is_nothrow_move_constructible<std::remove_reference_t<T>>::value &&
    std::is_nothrow_assignable<std::remove_reference_t<T>, std::remove_reference_t<U>&&>::value
)
{
    T old_value {std::move(obj)};
    obj = std::move(new_value);
    return old_value;
}

} // namespace estd

如果您使用左值引用作为要在obj中移动的值（即new_value必须是绑定到右值的右值引用），则该模板将被禁用，如果您使用的类型T为不能进行可构造的移动，或者如果可移动构造不适用于该右值。

这样，您可以定义noexcept移动ctor。 Demo here。我之所以只将函数限制为右值，是因为，尽管并非总是如此，但是复制并非noexcept，并且exchange应该在移动ctor中使用，但要保留它noexcept不能使那些ctor不能noexcept，并且出于明显的原因，这是不好的。

void do_stuff() noexcept
{ /*...*/ }

class Sample
{
    std::string mBody;
public:
    Sample(const std::string& body = ""): mBody {body} {}

    Sample(const Sample& s): mBody {s.mBody} {
        printf("%s\n", __PRETTY_FUNCTION__); // noexcept
    }

    Sample& operator=(const Sample& s) { 
        mBody = s.mBody; 
        printf("%s\n", __PRETTY_FUNCTION__); // noexcept
        return *this;
    }

    Sample(Sample&& dying) noexcept(
        noexcept(do_stuff()) && 
        noexcept(estd::rval_exchange(dying.mBody, {}))
    ):
        mBody {estd::rval_exchange(dying.mBody, {})}
    {
        do_stuff(); // noexcept
        printf("%s\n", __PRETTY_FUNCTION__); // noexcept
    }

    Sample& operator=(Sample&& dying) noexcept(
        noexcept(do_stuff()) && 
        noexcept(estd::rval_exchange(dying.mBody, {}))
    )
    {
        mBody = estd::rval_exchange(dying.mBody, {});
        do_stuff();
        printf("%s\n", __PRETTY_FUNCTION__); // noexcept
        return *this;
    }

    std::string body() const noexcept {return mBody;}
};

int main()
{
    std::cout << std::boolalpha;
    Sample rval{"wow such string very content"};
    Sample dummy;
    std::cout << noexcept( Sample(std::move(rval)) ) << std::endl; // prints true
    std::cout << noexcept( dummy = std::move(rval) ) << std::endl; // prints true

    // The rest only to show that move semantics actually work
    Sample f (std::move(rval));             // Calls move ctor
    std::cout << rval.body() << std::endl;  // prints empty line, empty string moved in rval
    std::cout << f.body() << std::endl;     // prints wow such string very content

    // estd::rval_exchange(f, rval); // Fails to compile bc rval is an lvalue reference, template disabled
    std::cout << (estd::rval_exchange(f, std::move(rval))).body() << std::endl; 
    // Ok, calls move ctor and move assignment (in estd::rval_exchange) and 
    // prints wow such string very content
    std::cout << f.body() << std::endl; // empty line, rval (empty) moved in f
    std::cout << "end" << std::endl;
}

为什么std :: exchange不是noexcept？

3 个答案: