接下来是遗留移动语义辅助类和函数的接口。

namespace boost
{
  namespace detail
  {
      template<typename T>
      struct thread_move_t
      {
        explicit thread_move_t(T& t_);
        T& operator*() const;
        T* operator->() const;
      private:
        void operator=(thread_move_t&);
      };
  }
  template<typename T>
  boost::detail::thread_move_t<T> move(boost::detail::thread_move_t<T> t);
}

我们可以按如下方式编写 MovableOny 类。您只需要遵循以下简单步骤

例如，thread 类定义了以下内容

class thread
{
  // ...
private:
    thread(thread&);
    thread& operator=(thread&);
public:
    detail::thread_move_t<thread> move()
    {
        detail::thread_move_t<thread> x(*this);
        return x;
    }
    operator detail::thread_move_t<thread>()
    {
        return move();
    }
    thread(detail::thread_move_t<thread> x)
    {
        thread_info=x->thread_info;
        x->thread_info.reset();
    }
    thread& operator=(detail::thread_move_t<thread> x)
    {
        thread new_thread(x);
        swap(new_thread);
        return *this;
    }
  // ...

};

此宏将类标记为不可复制，禁用复制构造和赋值。

此宏将类标记为可移动，声明所有到右值引用的隐式转换。

此宏将类型标记为可移动但不可复制，禁用复制构造和赋值。用户将需要编写移动构造函数/赋值才能完全编写一个可移动但不可复制的类。

此宏将类型标记为可复制且可移动。用户将需要编写移动构造函数/赋值和复制赋值才能完全编写一个可复制且可移动的类。

此宏用于在标记为 BOOST_THREAD_COPYABLE_AND_MOVABLE 或 BOOST_THREAD_MOVABLE_ONLY 的类的移动构造函数和赋值中实现可移植的语法。

BOOST_THREAD_RV_REF_BEG 和 BOOST_THREAD_RV_REF_END 在参数以 > 结尾时使用，以避免编译器错误。

虽然 Boost.Move 仿真允许使用点运算符访问右值引用 BOOST_THREAD_RV_REF(TYPE)，但遗留代码定义了 operator->。然后我们需要一个宏 BOOST_THREAD_RV 来掩盖这种差异。例如：

thread(BOOST_THREAD_RV_REF(thread) x)
{
    thread_info=BOOST_THREAD_RV(x).thread_info;
    BOOST_THREAD_RV(x).thread_info.reset();
}

这些宏的使用大大减少了 Boost.Thread 移动相关代码的大小。

虽然 Boost.Move 是最好的 C++03 移动仿真，但它存在一些限制，会影响库的使用方式。例如，使用以下声明

class thread {
  // ...
private:
  thread(thread &);
public:
  thread(rv<thread>&);
  // ...
};

即使 thread 可转换为 rv<thread>，这在某些编译器上也可能无法工作，因为编译器更喜欢私有复制构造函数。

thread mkth()
{
  return thread(f);
}

在这些编译器上，我们需要改为使用显式转换。该库提供了一个 move 成员函数，允许解决此问题。

thread mkth()
{
  return thread(f).move();
}

请注意，::boost::move 在这种情况下不能使用，因为 thread 不能隐式转换为 thread&。

thread mkth()
{
  return ::boost::move(thread(f));
}

为了使代码具有可移植性，Boost.Thread 用户需要使用宏 BOOST_THREAD_MAKE_RV_REF，可以像这样使用

thread mkth()
{
  return BOOST_THREAD_MAKE_RV_REF(thread(f));
}

请注意，遗留的 Boost.Thread 移动仿真也存在此限制。

由于 Boost.Move 也定义了 boost::move 函数，我们需要专门化 has_move_emulation_enabled_aux 元函数。

template <>
struct has_move_emulation_enabled_aux<thread>
  : BOOST_MOVE_BOOST_NS::integral_constant<bool, true>
{};

以便禁用以下 Boost.Move 重载

template <class T>
inline typename BOOST_MOVE_BOOST_NS::disable_if<has_move_emulation_enabled_aux<T>, T&>::type move(T& x);

宏 BOOST_THREAD_DCL_MOVABLE(CLASS), BOOST_THREAD_DCL_MOVABLE_BEG(T1) 和 BOOST_THREAD_DCL_MOVABLE_END 用于此目的。例如：

BOOST_THREAD_DCL_MOVABLE(thread)

和

BOOST_THREAD_DCL_MOVABLE_BEG(T) promise<T> BOOST_THREAD_DCL_MOVABLE_END