我试图尽可能接近 强异常保证，但是在玩弄 std::move_if_noexcept 时，我遇到了一些看似奇怪的行为。

尽管下面的类中的移动赋值操作符被标记为noexcept，复制赋值操作符在被调用时被调用带有相关函数的返回值。

struct A {
  A ()         { /* ... */ }
  A (A const&) { /* ... */ }

  A& operator= (A const&) noexcept { log ("copy-assign"); return *this; }
  A& operator= (A&&)      noexcept { log ("move-assign"); return *this; }

  static void log (char const * msg) {
    std::cerr << msg << "\n";
  }
};

int main () {
  A x, y;

  x = std::move_if_noexcept (y); // prints "copy-assign"
}

问题

• 为什么在前面的代码片段中没有调用 move-assignment 运算符？

最佳答案

简介

move_if_noexcept 的名称当然暗示该函数将产生一个 rvalue-reference，只要这个操作是 noexcept，并且有了这个请记住，我们很快就会意识到两件事:

1. 从 T& 到 T&& 或 T const& 的简单转换永远不会抛出异常，那么这样的函数的目的是什么？
2. move_if_noexcept如何神奇地推断出使用返回值的上下文？

实现的答案(2) 既可怕又自然； move_if_noexcept 根本无法推断出这样的上下文(因为它不是读心器)，这反过来又意味着该函数必须按照一些静态规则来运行。

TL;DR

move_if_noexcept 将根据参数类型的异常规范 move- 有条件地返回一个 rvalue-reference constructor，它仅用于初始化对象时(即不分配给它们时)。

template<class T>
void intended_usage () {
  T first;
  T second (std::move_if_noexcept (first));
}

更好的名字应该是 move_if_move_ctor_is_noexcept_or_the_only_option;虽然打字有点乏味，但至少可以表达预期的用途。

move_if_noexcept

阅读产生 std::move_if_noexcept 的提案 (n3050 )，我们发现以下段落(强调我的):

We propose that instead of using std::move(x) in those cases, thus granting permission for the compiler to use any available move constructor, maintainers of these particular operations should use std::move_if_noexcept(x), which grants permission move unless it could throw and the type is copyable.

Unless x is a move-only type, or is known to have a nonthrowing move constructor, the operation would fall back to copying x, just as though x had never acquired a move constructor at all.

那么，move_if_noexcept 是做什么的？

std::move_if_noexcept 将有条件地将传递的 lvalue-reference 转换为 rvalue-reference，除非；

• 一个潜在的 move-constructor 可能会抛出，并且；
• 类型为CopyConstructible .

// Standard Draft n4140 : [utility]p2

template<class T>
constexpr conditional_t<
  !is_nothrow_move_constructible::value && is_copy_constructible<T>::value,
  const T&, T&&
> move_if_noexcept (T& x) noexcept;

这基本上意味着它只会产生一个 rvalue-reference 如果它可以证明它是唯一可行的替代方案，或者如果它保证不会抛出异常(通过 表示没有异常(exception))。

判决

std::move 是对 rvalue-reference 的无条件强制转换，而 std::move_if_noexcept 取决于对象可以使用的方式是 move-constructed - 因此它应该只在我们实际构造对象的地方使用，而不是在我们分配对象时使用。

由于 move_if_noexcept 找不到标记为 noexcept，但由于它有一个 copy-constructor，该函数将产生一个适合这种情况的类型，A const&。

请注意 copy-constructor 有资格作为 MoveConstructible 的类型，这意味着我们可以让 move_if_noexcept 返回一个 rvalue-reference 通过对您的代码段进行以下调整:

struct A {
  A ()                  { /* ... */ }
  A (A const&) noexcept { /* ... */ }
  
  ...
};

示例

struct A {
  A ();
  A (A const&);
};

A a1;
A a2 (std::move_if_noexcept (a1)); // `A const&` => copy-constructor

struct B {
  B ();
  B (B const&);
  B (B&&) noexcept;
};

B b1;
B b2 (std::move_if_noexcept (b1)); // `B&&` => move-constructor
                                   //          ^ it's `noexcept`

struct C {
  C ();
  C (C&&);
};

C c1;
C c2 (std::move_if_noexcept (c1)); // `C&&` => move-constructor
                                   //          ^ the only viable alternative

struct D {
  C ();
  C (C const&) noexcept;
};

C c1;
C c2 (std::move_if_noexcept (c1)); // C&& => copy-constructor
                                   //        ^ can be invoked with `T&&`

延伸阅读:

• cppreference.com - MoveConstructible
• cppreference.com - CopyConstructible
• cppreference.com - std::move_if_noexcept

关于c++ - 即使 move-assignment 是 noexcept，std::move_if_noexcept 也会调用 copy-assignment；为什么？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28598488/