Перемещаемая версия std::function

Question

Так как std::function является копируемым, стандарт требует, чтобы вызываемые элементы, используемые для его создания, также были копируемыми:

N337 (20.8.11.2.1)

template<class F> function(F f);

Требуется: F должен быть CopyConstructible. f Должен быть Callable (20.8.11.2) для типов аргументов ArgTypes и тип возврата R, Конструктор копии и деструктор A не должны создавать исключений.

Это означает, что невозможно сформировать std::function из не подлежащего копированию объекта связывания или лямбды, которая захватывает тип "только для перемещения", такой как std::unique_ptr,

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

Answer 1

Нет, нет версии только для перемещения std::function в С ++ std библиотека. (По состоянию на C++14)

Как можно быстрее делегатов является реализация std::function как класс, который оказывается быстрее, чем большинство std::function реализации во многих std библиотеки, и это должно быть легко раскошелиться на move а также copy версия.

Оборачивать ваш move единственный функциональный объект в shared_ptr<F> в классе с переадресацией operator() это другой подход.

Вот task эскиз:

template<class Sig>
struct task;

namespace details {
  template<class Sig>
  struct task_iimpl;
  template<class R, class...Args>
  struct task_iimpl<R(Args...)> {
    virtual ~task_iimpl() {}
    virtual R invoke(Args&&...args) const = 0;
  };
  template<class F, class Sig>
  struct task_impl;
  template<class F, class R, class...Args>
  struct task_impl<F,R(Args...)>:
    task_iimpl<R(Args...)>
  {
    F f;
    template<class T>
    task_impl(T&& t):f(std::forward<T>(t)) {}
    virtual R invoke(Args&&...args) const override {
      return f( std::forward<Args>(args...) );
    }
  };
  template<class F, class...Args>
  struct task_impl<F,void(Args...)>:
    task_iimpl<void(Args...)>
  {
    F f;
    template<class T>
    task_impl(T&& t):f(std::forward<T>(t)) {}
    virtual void invoke(Args&&...args) const override {
      f( std::forward<Args>(args...) );
    }
  };
}
template<class R, class...Args>
struct task<R(Args...)> {
  virtual ~task_iimpl() {}
  R operator()(Args...args) const {
    return pImpl->invoke(std::forward<Args>(args...));
  }
  explicit operator bool()const{ return static_cast<bool>(pImpl); }
  task(task &&)=default;
  task& operator=(task &&)=default;
  task()=default;

  // and now for a mess of constructors
  // the rule is that a task can be constructed from anything
  // callable<R(Args...)>, destroyable, and can be constructed
  // from whatever is passed in.  The callable feature is tested for
  // in addition, if constructed from something convertible to `bool`,
  // then if that test fails we construct an empty task.  This makes us work
  // well with empty std::functions and function pointers and other tasks
  // that are call-compatible, but not exactly the same:
  struct from_func_t {};
  template<class F,
    class dF=std::decay_t<F>,
    class=std::enable_if_t<!std::is_same<dF, task>{}>,
    class FR=decltype(std::declval<F const&>()(std::declval<Args>()...)),
    std::enable_if_t<std::is_same<R, void>{} || std::is_convertible<FR, R>{} >*=0,
    std::enable_if_t<std::is_convertible<dF, bool>{}>*=0
  >
  task(F&& f):
    task(
      static_cast<bool>(f)?
      task( from_func_t{}, std::forward<F>(f) ):
      task()
    )
  {}
  template<class F,
    class dF=std::decay_t<F>,
    class=std::enable_if_t<!std::is_same<dF, task>{}>,
    class FR=decltype(std::declval<F const&>()(std::declval<Args>()...)),
    std::enable_if_t<std::is_same<R, void>{} || std::is_convertible<FR, R>{} >*=0,
    std::enable_if_t<!std::is_convertible<dF, bool>{}>*=0
  >
  task(F&& f):
    task( from_func_t{}, std::forward<F>(f) )
  {}

  task(std::nullptr_t):task() {}
  // overload resolution helper when signatures match exactly:
  task( R(*pf)(Args...) ):
    task( pf?task( from_func_t{}, pf ):task() )
  {}
private:
  template<class F,
    class dF=std::decay_t<F>
  >
  task(from_func_t, F&& f):
    pImpl( std::make_unique<details::task_impl<dF,R(Args...)>>(
      std::forward<F>(f)
    )
  {}

  std::unique_ptr<details::task_iimpl<R(Args...)> pImpl;
};

но это не было проверено или скомпилировано, я просто написал это.

Более промышленная версия должна включать в себя небольшую буферную оптимизацию (SBO) для хранения небольших вызываемых объектов (при условии, что они являются подвижными; если они не являются подвижными, сохраняйте в куче, чтобы разрешить перемещение), и get-pointer-if-you-предположите-the- типа право (как std::function).

Answer 2

Да, есть предложение для std::move_only_function в текущем проекте C++23, принятом в 2021-10:

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

См. также запись cppreference в std::move_only_function:

Шаблон класса std::move_only_function представляет собой оболочку полиморфной функции общего назначения. Объекты std::move_only_function могут хранить и вызывать любые конструктивные (не обязательно должны быть конструируемыми для перемещения) вызываемые цели — функции, лямбда-выражения, выражения связывания или другие объекты функций, а также указатели на функции-члены и указатели на объекты-члены.
...
std::move_only_function удовлетворяет требованиям MoveConstructible и MoveAssignable, но не удовлетворяет CopyConstructible или CopyAssignable.

Answer 3

Как отмечали другие, не существует версии только для перемещения std::function в библиотеке. Ниже приводится обходной путь, который повторное использование (злоупотребления?) std::function и позволяет ему принимать типы только для перемещения. Это в значительной степени вдохновлено реализацией dyp в комментариях, поэтому большая заслуга ему принадлежит:

#include <functional>
#include <iostream>
#include <type_traits>
#include <utility>

template<typename T>
class unique_function : public std::function<T>
{
    template<typename Fn, typename En = void>
    struct wrapper;

    // specialization for CopyConstructible Fn
    template<typename Fn>
    struct wrapper<Fn, std::enable_if_t< std::is_copy_constructible<Fn>::value >>
    {
        Fn fn;

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

    // specialization for MoveConstructible-only Fn
    template<typename Fn>
    struct wrapper<Fn, std::enable_if_t< !std::is_copy_constructible<Fn>::value
        && std::is_move_constructible<Fn>::value >>
    {
        Fn fn;

        wrapper(Fn&& fn) : fn(std::forward<Fn>(fn)) { }

        wrapper(wrapper&&) = default;
        wrapper& operator=(wrapper&&) = default;

        // these two functions are instantiated by std::function
        // and are never called
        wrapper(const wrapper& rhs) : fn(const_cast<Fn&&>(rhs.fn)) { throw 0; } // hack to initialize fn for non-DefaultContructible types
        wrapper& operator=(wrapper&) { throw 0; }

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

    using base = std::function<T>;

public:
    unique_function() noexcept = default;
    unique_function(std::nullptr_t) noexcept : base(nullptr) { }

    template<typename Fn>
    unique_function(Fn&& f) : base(wrapper<Fn>{ std::forward<Fn>(f) }) { }

    unique_function(unique_function&&) = default;
    unique_function& operator=(unique_function&&) = default;

    unique_function& operator=(std::nullptr_t) { base::operator=(nullptr); return *this; }

    template<typename Fn>
    unique_function& operator=(Fn&& f)
    { base::operator=(wrapper<Fn>{ std::forward<Fn>(f) }); return *this; }

    using base::operator();
};

using std::cout; using std::endl;

struct move_only
{
    move_only(std::size_t) { }

    move_only(move_only&&) = default;
    move_only& operator=(move_only&&) = default;

    move_only(move_only const&) = delete;
    move_only& operator=(move_only const&) = delete;

    void operator()() { cout << "move_only" << endl; }
};

int main()
{
    using fn = unique_function<void()>;

    fn f0;
    fn f1 { nullptr };
    fn f2 { [](){ cout << "f2" << endl; } }; f2();
    fn f3 { move_only(42) }; f3();
    fn f4 { std::move(f2) }; f4();

    f0 = std::move(f3); f0();
    f0 = nullptr;
    f2 = [](){ cout << "new f2" << endl; }; f2();
    f3 = move_only(69); f3();

    return 0;
}

Рабочая версия к колиру.