Передача некопируемого объекта закрытия в параметр std::function

Есть такой подход:

template< typename signature >
struct make_copyable_function_helper;
template< typename R, typename... Args >
struct make_copyable_function_helper<R(Args...)> {
  template<typename input>
  std::function<R(Args...)> operator()( input&& i ) const {
    auto ptr = std::make_shared< typename std::decay<input>::type >( std::forward<input>(i) );
    return [ptr]( Args... args )->R {
      return (*ptr)(std::forward<Args>(args)...);
    };
  }
};

template< typename signature, typename input >
std::function<signature> make_copyable_function( input && i ) {
  return make_copyable_function_helper<signature>()( std::forward<input>(i) );
}

где мы создаем общий указатель на наши данные, затем создаем копируемую лямбду, которая захватывает этот общий указатель, затем мы оборачиваем эту копируемую лямбду в std::function запрошенной подписи.

В вашем случае выше вы бы просто:

doit( make_copyable_function<void()>( [p = std::move(p)] () { std::cout << *p << std::endl; } ) );

Немного более продвинутая версия откладывает стирание типа и добавляет уровень идеальной пересылки для уменьшения накладных расходов:

template<typename input>
struct copyable_function {
  typedef typename std::decay<input>::type stored_input;
  template<typename... Args>
  auto operator()( Args&&... args )->
    decltype( std::declval<input&>()(std::forward<Args>(args)...) )
  {
    return (*ptr)(std::forward<Args>(args));
  }
  copyable_function( input&& i ):ptr( std::make_shared<stored_input>( std::forward<input>(i) ) ) {}
  copyable_function( copyable_function const& ) = default;
private:
  std::shared_ptr<stored_input> ptr;
};
template<typename input>
copyable_function<input> make_copyable_function( input&& i ) {
  return {std::forward<input>(i)}; 
}

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

В C++14 это можно сделать еще короче:

template< class F >
auto make_copyable_function( F&& f ) {
  using dF=std::decay_t<F>;
  auto spf = std::make_shared<dF>( std::forward<F>(f) );
  return [spf](auto&&... args)->decltype(auto) {
    return (*spf)( decltype(args)(args)... );
  };
}

полностью отказаться от вспомогательного типа.

Если время жизни объекта закрытия не является проблемой, вы можете передать его в ссылочной оболочке:

int main()
{
    std::unique_ptr<int> p(new int(5));
    auto f = [p = std::move(p)]{
        std::cout << *p << std::endl;
    };
    doit(std::cref(f));
}

Очевидно, что это не применимо к каждому сценарию, но подойдет для вашей программы-примера.

РЕДАКТИРОВАТЬ: взглянув на N3797 (рабочий проект С++ 14) § 20.9.11.2.1 [func.wrap.func.con] p7, требование CopyConstructible все еще существует. Интересно, есть ли техническая причина, по которой нельзя перейти к MoveConstructible, или комитет просто не удосужился этим заняться?

РЕДАКТИРОВАТЬ: Отвечая на мой собственный вопрос: std::function - это CopyConstructible, поэтому обернутый функтор также должен быть CopyConstructible.

Если вы знаете, что на самом деле не собираетесь копировать свой объект функции, вы можете просто обернуть его в тип, который заставит компилятор думать, что его можно скопировать:

struct ThrowOnCopy {
  ThrowOnCopy() = default;
  ThrowOnCopy(const ThrowOnCopy&) { throw std::logic_error("Oops!"); }
  ThrowOnCopy(ThrowOnCopy&&) = default;
  ThrowOnCopy& operator=(ThrowOnCopy&&) = default;
};

template<typename T>
  struct FakeCopyable : ThrowOnCopy
  {
    FakeCopyable(T&& t) : target(std::forward<T>(t)) { }

    FakeCopyable(FakeCopyable&&) = default;

    FakeCopyable(const FakeCopyable& other)
    : ThrowOnCopy(other),                             // this will throw
      target(std::move(const_cast<T&>(other.target))) // never reached
    { }

    template<typename... Args>
      auto operator()(Args&&... a)
      { return target(std::forward<Args>(a)...); }

    T target;
  };


template<typename T>
  FakeCopyable<T>
  fake_copyable(T&& t)
  { return { std::forward<T>(t) }; }


// ...

doit( fake_copyable([p = std::move(p)] () { std::cout << *p << std::endl; }) );

Шаблон функции fake_copyable создает оболочку, которая является CopyConstructible согласно компилятору (и <type_traits>), но не может быть скопирована во время выполнения.

Если вы сохраните FakeCopyable<X> в std::function, а затем в конечном итоге скопируете std::function, вы получите std::logic_error, но если вы переместите только std::function, все будет работать нормально.

target(std::move(const_cast<T&>(other.target))) выглядит тревожно, но этот инициализатор никогда не запустится, потому что инициализатор базового класса сработает первым. Таким образом, тревожное const_cast на самом деле никогда не происходит, оно просто делает компилятор счастливым.