Связывать структуру только для перемещения

Ответ 1

std::function не может принимать вызовы только для перемещения. Он стирает переданный тип, чтобы вызвать (с подписью), уничтожить и скопировать. ¹

Запись только для перемещения std::function - это только немного работы. Вот удар по нему в другом контексте. живой пример.

std::packaged_task забавно также является призывчиком типа-ластик только для движения, но он более тяжелый, чем вы, вероятно, хотите, и получение ценности - это боль.

Более простым решением является злоупотребление общим указателем:

template<class F>
auto shared_function( F&& f ) {
  auto pf = std::make_shared<std::decay_t<F>>(std::forward<F>(f));
  return [pf](auto&&... args){
    return (*pf)(decltype(args)(args)...);
  };
}

который обертывает некоторый вызываемый объект в общий указатель, помещает это в лямбда идеальной пересылкой лямбда.

Это иллюстрирует проблему - вызов не работает! Все вышесказанное имеет const invokation.

То, что вы хотите, - это задача, которую вы можете вызвать только один раз.

template<class Sig>
struct task_once;

namespace details_task_once {
  template<class Sig>
  struct ipimpl;
  template<class R, class...Args>
  struct ipimpl<R(Args...)> {
    virtual ~ipimpl() {}
    virtual R invoke(Args&&...args) && = 0;
  };
  template<class Sig, class F>
  struct pimpl;
  template<class R, class...Args, class F>
  struct pimpl<R(Args...), F>:ipimpl<R(Args...)> {
    F f;
    template<class Fin>
    pimpl(Fin&&fin):f(std::forward<Fin>(fin)){}
    R invoke(Args&&...args) && final override {
      return std::forward<F>(f)(std::forward<Args>(args)...);
    };
  };
  // void case, we don't care about what f returns:
  template<class...Args, class F>
  struct pimpl<void(Args...), F>:ipimpl<void(Args...)> {
    F f;
    template<class Fin>
    pimpl(Fin&&fin):f(std::forward<Fin>(fin)){}
    void invoke(Args&&...args) && final override {
      std::forward<F>(f)(std::forward<Args>(args)...);
    };
  };
}
template<class R, class...Args>
struct task_once<R(Args...)> {
  task_once(task_once&&)=default;
  task_once&operator=(task_once&&)=default;
  task_once()=default;
  explicit operator bool() const { return static_cast<bool>(pimpl); }

  R operator()(Args...args) && {
    auto tmp = std::move(pimpl);
    return std::move(*tmp).invoke(std::forward<Args>(args)...);
  }
  // if we can be called with the signature, use this:
  template<class F,
    class R2=R,
    std::enable_if_t<
        std::is_convertible<std::result_of_t<F&&(Args...)>,R2>{}
        && !std::is_same<R2, void>{}
    >* = nullptr
  >
  task_once(F&& f):task_once(std::forward<F>(f), std::is_convertible<F&,bool>{}) {}

  // the case where we are a void return type, we don't
  // care what the return type of F is, just that we can call it:
  template<class F,
    class R2=R,
    class=std::result_of_t<F&&(Args...)>,
    std::enable_if_t<std::is_same<R2, void>{}>* = nullptr
  >
  task_once(F&& f):task_once(std::forward<F>(f), std::is_convertible<F&,bool>{}) {}

  // this helps with overload resolution in some cases:
  task_once( R(*pf)(Args...) ):task_once(pf, std::true_type{}) {}
  // = nullptr support:
  task_once( std::nullptr_t ):task_once() {}

private:
  std::unique_ptr< details_task_once::ipimpl<R(Args...)> > pimpl;

// build a pimpl from F.  All ctors get here, or to task() eventually:
  template<class F>
  task_once( F&& f, std::false_type /* needs a test?  No! */ ):
    pimpl( new details_task_once::pimpl<R(Args...), std::decay_t<F>>{ std::forward<F>(f) } )
  {}
  // cast incoming to bool, if it works, construct, otherwise
  // we should be empty:
  // move-constructs, because we need to run-time dispatch between two ctors.
  // if we pass the test, dispatch to task(?, false_type) (no test needed)
  // if we fail the test, dispatch to task() (empty task).
  template<class F>
  task_once( F&& f, std::true_type /* needs a test?  Yes! */ ):
    task_once( f?task_once( std::forward<F>(f), std::false_type{} ):task_once() )
  {}
};

живой пример.

Обратите внимание, что вы можете вызывать только () в контексте rvalue с помощью вышеприведенного task_once. Это связано с тем, что () является деструктивным, как и должно быть в вашем случае.

К сожалению, вышеизложенное полагается на С++ 14. И мне не нравится писать код С++ 11 в наши дни. Итак, вот более простое решение С++ 11, которое менее эффективно:

std::function<void()> a;
{
    Bar b;
    b.i = 10;
    auto pb = std::make_shared<Bar>(std::move(b));
    a = [pb]{ return foo(std::move(*pb)); };
}
a();

Это перемещает перемещенную копию b в общий указатель, сохраняет ее в std::function, а затем разрушает ее при первом вызове ().

¹ Он реализует перемещение без него (если только он не использует оптимизацию небольших функций, где я надеюсь, что он использует перемещение типа). Он также реализует тип конвертирования назад, но каждый тип поддерживает это. Для некоторых типов он поддерживает check-for-null (т.е. Cast to bool явно), но я честно не уверен в том, какие именно типы он делает.

Ответ 2

Вы можете обойти CopyConstructible ограничение std::function с помощью комбинации указателей, lambdas и std:: bind:

auto lambda = [](Bar* b){::foo(std::move(*b));};
std::function<void()> a = std::bind(lambda, &b);
a();

Пример

Изменить

Один вкладыш в С++ 11 с лямбдой и захватом по ссылке

std::function<void()> a = [&b](){::foo(std::move(b));};
a()

Пример2

Edit2

(Перемещение комментария в мой ответ)

После редактирования кода, который добавляет ограничение, которое объект функции должен иметь, чтобы пережить область действия переменной, привязанной к функции, мы можем выполнить это все еще с помощью лямбда, только теперь мы должны записать shared_ptr, который использует распределение и перемещает конструкцию, чтобы провести Bar.

В приведенном ниже примере я использую обобщенный захват С++ 14 для захвата shared_ptr. @Yakk solution переводит это на С++ 11.

std::function<void()> a;
{
    Bar b;
    b.i = 10;
    a = [b2 = std::make_shared<decltype(b)>(std::move(b))]()
    {
        // move the underlying object out from under b2
        // which means b2 is in a valid but undefined state afterwards
        ::foo(std::move(*b2));
    }; 
}

Пример3