为什么互斥锁和条件变量可以轻松复制？

Question

LWG 2424 在 C++14 中将原子、互斥体和条件变量的不良状态讨论为 trivially copyable。我很欣赏修复是already lined up，但std::mutex、std::condition variable 等。似乎有非平凡的析构函数。例如：

30.4.1.2.1 类互斥体 [thread.mutex.class]

namespace std {
  class mutex {
  public:
    constexpr mutex() noexcept;
    ~mutex(); // user-provided => non-trivial

    …
  }
}

这难道不应该取消它们的可复制性吗？

Answer 1

要么是我的错误，要么是我被错误引用了，老实说，我不记得是哪一个。

但是，我对此主题有以下非常强烈的建议：

请勿使用is_trivial 或is_trivially_copyable！永远！！！

改为使用以下之一：

is_trivially_destructible<T>
is_trivially_default_constructible<T>
is_trivially_copy_constructible<T>
is_trivially_copy_assignable<T>
is_trivially_move_constructible<T>
is_trivially_move_assignable<T>

理由：

tldr：看到这个excellent question and correct answer.

没有人（包括我自己）能记住is_trivial 和is_trivially_copyable 的定义。如果你碰巧查了一下，然后花 10 分钟分析它，它可能会也可能不会像你直觉认为的那样做。如果您设法正确分析它，CWG 很可能会在很少或根本不通知的情况下更改其定义，并使您的代码无效。

使用is_trivial 和is_trivially_copyable 是在玩火。

但是这些：

is_trivially_destructible<T>
is_trivially_default_constructible<T>
is_trivially_copy_constructible<T>
is_trivially_copy_assignable<T>
is_trivially_move_constructible<T>
is_trivially_move_assignable<T>

做他们听起来像他们做的事情，并且不太可能改变他们的定义。必须单独处理每个特殊成员似乎过于冗长。但它会在代码的稳定性/可靠性方面得到回报。如果必须，将这些单独的特征打包成一个自定义特征。

更新

例如，clang & gcc 编译这个程序：

#include <type_traits>

template <class T>
void
test()
{
    using namespace std;
    static_assert(!is_trivial<T>{}, "");
    static_assert( is_trivially_copyable<T>{}, "");
    static_assert( is_trivially_destructible<T>{}, "");
    static_assert( is_destructible<T>{}, "");
    static_assert(!is_trivially_default_constructible<T>{}, "");
    static_assert(!is_trivially_copy_constructible<T>{}, "");
    static_assert( is_trivially_copy_assignable<T>{}, "");
    static_assert(!is_trivially_move_constructible<T>{}, "");
    static_assert( is_trivially_move_assignable<T>{}, "");
}

struct X
{
    X(const X&) = delete;
};

int
main()
{
    test<X>();
}

请注意，X 是可简单复制的，但不是可简单复制构造的。据我所知，这是符合规范的行为。

VS-2015 目前表示X既不可简单复制也不可简单复制构造。根据目前的规范，我认为这是错误的，但它确实符合我的常识。

如果我需要memcpy 来未初始化内存，我会相信is_trivially_copy_constructible 而不是is_trivially_copyable 向我保证这样的操作是可以的。如果我想memcpy 来初始化内存，我会检查is_trivially_copy_assignable。

Answer 2

并非所有实现都为mutex 提供了重要的析构函数。请参阅 libstdc++（并假设已定义 __GTHREAD_MUTEX_INIT）：

  // Common base class for std::mutex and std::timed_mutex
  class __mutex_base
  {
  // […]
#ifdef __GTHREAD_MUTEX_INIT
    __native_type  _M_mutex = __GTHREAD_MUTEX_INIT;

    constexpr __mutex_base() noexcept = default;
#else
  // […]

    ~__mutex_base() noexcept { __gthread_mutex_destroy(&_M_mutex); }
#endif
  // […]
  };

  /// The standard mutex type.
  class mutex : private __mutex_base
  {
    // […]
    mutex() noexcept = default;
    ~mutex() = default;

    mutex(const mutex&) = delete;
    mutex& operator=(const mutex&) = delete;
  };

mutex 的此实现既符合标准又可轻松复制（可以验证 via Coliru）。同样，没有什么能阻止实现使condition_variable 易于破坏（参见[thread.condition.condvar]/6，尽管我找不到这样的实现）。

底线是，我们需要明确、规范的保证，而不是对 condition_variable 做什么或不必须做什么（以及它必须如何完成）做巧妙、微妙的解释。

Answer 3

从语言律师的角度来看这一点很重要。

基本上不可能实现mutex、条件变量等以使它们易于复制的方式。在某些时候，您必须编写一个析构函数，而该析构函数很可能需要做一些重要的工作。

但这没关系。为什么？因为该标准没有明确声明此类类型不可轻易复制。因此，从标准的角度来看，理论上可能这样的对象可以简单地复制。

即使没有任何功能实现都可以，但 N4460 的重点是非常清楚地表明此类类型永远不会被轻易复制。