Далее следует интерфейс унаследованного движения семантического помощника класса и функции.

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 можно следующим образом. Вам просто нужно следовать этим простым шагам:

Например, класс потоков определяет следующее:

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;
    }
  // ...
};

Этот макрос обозначает класс как не копируемый, отключающий конструкцию и присвоение копии.

Этот макрос обозначает класс как подвижный, объявляя все неявные конверсии ссылкой на значение r.

Этот макрос обозначает тип как подвижный, но не копируемый, отключающий конструкцию и назначение копии. Пользователю нужно будет написать конструктор/назначение движения, чтобы полностью написать подвижный, но не копируемый класс.

Этот макрос обозначает тип как копируемый и подвижный. Пользователю необходимо будет написать конструктор/назначение движения и задание на копирование, чтобы полностью написать копируемый и подвижный класс.

Этот макрос используется для достижения портативного синтаксиса в движущихся конструкторах и назначениях для классов, помеченных как<BOOST_THREAD_COPYABLE_AND_MOVABLE>или<BOOST_THREAD_MOVABLE_ONLY>.

<BOOST_THREAD_RV_REF_BEG>и<BOOST_THREAD_RV_REF_END>используются, когда параметр заканчивается<>>, чтобы избежать ошибки компилятора.

Пока буст. Эмуляция перемещения позволяет получить доступ к ссылке rvalue<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. Код, связанный с движением потока.

Пока буст. Move - лучшая эмуляция C++03, есть некоторые ограничения, которые влияют на способ использования библиотеки. Например, со следующими заявлениями

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

Это не может работать на некоторых компиляторах, даже если поток конвертируется в<rv<thread>>, потому что компилятор предпочитает частный конструктор копий.

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

На этих компиляторах мы должны использовать явное преобразование. Библиотека предоставляет функцию члена движения, которая позволяет обойти проблему.

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

Обратите внимание, что<::boost::move>не может использоваться в этом случае, поскольку поток не является неявно конвертируемым в<thread&>.

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

Чтобы сделать код портативным Boost. Поток должен использовать макрос<BOOST_THREAD_MAKE_RV_REF>, который может быть использован как в

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

Обратите внимание, что это ограничение разделяется и наследием Boost. Эмуляция движения нитки.

Как Буст. Движение также определяет функцию<boost::move>, которую мы должны специализировать<has_move_emulation_enabled_aux>.

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

Таким образом, следующее повышение. Перемещение перегрузки отключено

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