23 General utilities library [utilities]

23.14 Function objects [function.objects]

23.14.13 Polymorphic function wrappers [func.wrap]

23.14.13.2 Class template function [func.wrap.func]

namespace std {
  template<class> class function; // not defined

  template<class R, class... ArgTypes>
  class function<R(ArgTypes...)> {
  public:
    using result_type = R;

    // [func.wrap.func.con], construct/copy/destroy
    function() noexcept;
    function(nullptr_t) noexcept;
    function(const function&);
    function(function&&);
    template<class F> function(F);

    function& operator=(const function&);
    function& operator=(function&&);
    function& operator=(nullptr_t) noexcept;
    template<class F> function& operator=(F&&);
    template<class F> function& operator=(reference_wrapper<F>) noexcept;

    ~function();

    // [func.wrap.func.mod], function modifiers
    void swap(function&) noexcept;

    // [func.wrap.func.cap], function capacity
    explicit operator bool() const noexcept;

    // [func.wrap.func.inv], function invocation
    R operator()(ArgTypes...) const;

    // [func.wrap.func.targ], function target access
    const type_info& target_type() const noexcept;
    template<class T>       T* target() noexcept;
    template<class T> const T* target() const noexcept;
  };

  template<class R, class... ArgTypes>
    function(R(*)(ArgTypes...)) -> function<R(ArgTypes...)>;

  template<class F> function(F) -> function<see below>;

  // [func.wrap.func.nullptr], Null pointer comparisons
  template <class R, class... ArgTypes>
    bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;

  template <class R, class... ArgTypes>
    bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;

  template <class R, class... ArgTypes>
    bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;

  template <class R, class... ArgTypes>
    bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;

  // [func.wrap.func.alg], specialized algorithms
  template <class R, class... ArgTypes>
    void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
}

function Шаблон класса обеспечивает полиморфные упаковщики, обобщающие понятие указателя функции. Оболочки могут хранить, копировать и вызывать произвольныеcallable objects, заданные a call signature, что позволяет функциям быть первоклассными объектами.

Acallable typeF используетсяLvalue-Callable для типов аргументовArgTypes и типа возвращаемого значения,R если выражение INVOKE<R>(declval<F&>(), declval<ArgTypes>()...), рассматриваемое как aunevaluated operand, имеет правильный формат ([func.require]).

function Шаблон класса является call wrapper которогоcall signature являетсяR(ArgTypes...).

[ Note: Типы, определенные в руководствах по вычетам,function могут измениться в будущих версиях этого международного стандарта. ] — end note

23.14.13.2.1 function construct/copy/destroy [func.wrap.func.con]

function() noexcept;

Postconditions:!*this.

function(nullptr_t) noexcept;

Postconditions:!*this.

function(const function& f);

Postconditions:!*this если!f; в противном случае *this нацелена на копиюf.target().

Throws: не должен генерировать исключения, еслиfцель является специализациейreference_wrapper или указателем на функцию. В противном случае может вызватьbad_alloc или любое исключение, созданное конструктором копирования сохраненного вызываемого объекта. [ Note: Реализациям рекомендуется избегать использования динамически выделяемой памяти для небольших вызываемых объектов, например, где fцелью является объект, содержащий только указатель или ссылку на объект и указатель на функцию-член. ] — end note

function(function&& f);

Postconditions: Если!f,*this не имеют целей; в противном случае цель*this эквивалентна целиf до построения и f находится в допустимом состоянии с неопределенным значением.

Throws: не должен генерировать исключения, еслиfцель является специализациейreference_wrapper или указателем на функцию. В противном случае может вызватьbad_alloc или любое исключение, созданное конструктором копирования или перемещения сохраненного вызываемого объекта. [ Note: Реализациям рекомендуется избегать использования динамически выделяемой памяти для небольших вызываемых объектов, например, гдеfцелью является объект, содержащий только указатель или ссылку на объект и указатель на функцию-член. ] — end note

template<class F> function(F f);

Requires:F будетCopyConstructible.

Remarks: Этот шаблон конструктора не должен участвовать в разрешении перегрузки, если только он не F предназначенLvalue-Callable для типов аргументов ArgTypes... и типа возвращаемого значенияR.

Postconditions:!*this если выполняется какое-либо из следующих условий:

(9.1)
f - значение указателя нулевой функции.
(9.2)
f - значение указателя на нулевой член.
(9.3)
F является экземпляромfunction шаблона класса, а !f.

В противном случае*this нацелена на копию,f инициализированную с помощьюstd::move(f). [ Note: Реализациям рекомендуется избегать использования динамически выделяемой памяти для небольших вызываемых объектов, например, гдеf объект, содержащий только указатель или ссылку на объект и указатель на функцию-член. ] — end note

Throws: не должен генерировать исключения, еслиf это указатель на функцию илиreference_wrapper<T> для некоторыхT. В противном случае может вызватьbad_alloc или любое исключение, созданное конструкторомFкопирования или перемещения.

template<class F> function(F) -> function<see below>;

Remarks: Это руководство по выводу участвует в разрешении перегрузки только в том случае, если &F::operator() оно правильно сформировано, когда рассматривается как неоцененный операнд. В том случае, еслиdecltype(&F::operator()) is имеет форму R(G::*)(A...)cv& $_{o p t}$ noexcept $_{o p t}$ для типа классаG, то выводимый тип имеет видfunction<R(A...)>.

[ Example:

void f() {
  int i{5};
  function g = [&](double) { return i; }; // deduces function<int(double)>
}

— end example ]

function& operator=(const function& f);

Effects: Как если быfunction(f).swap(*this);

Returns:*this.

function& operator=(function&& f);

Effects: Заменяет цель*this на цельf.

Returns:*this.

function& operator=(nullptr_t) noexcept;

Effects: Если*this != nullptr, уничтожает цельthis.

Postconditions:!(*this).

Returns:*this.

template<class F> function& operator=(F&& f);

Effects: Как будто по:function(std::forward<F>(f)).swap(*this);

Returns:*this.

Remarks: Этот оператор присваивания не должен участвовать в разрешении перегрузки, кромеdecay_t<F> как Lvalue-Callable для типов аргументовArgTypes... и типа возвращаемого значенияR.

template<class F> function& operator=(reference_wrapper<F> f) noexcept;

Effects: Как будто по:function(f).swap(*this);

Returns:*this.

~function();

Effects: Если*this != nullptr, уничтожает цельthis.

23.14.13.2.2 function modifiers [func.wrap.func.mod]

void swap(function& other) noexcept;

Effects: меняет местами цели*this иother.

23.14.13.2.3 function capacity [func.wrap.func.cap]

explicit operator bool() const noexcept;

Returns:true если*this есть цель, иначеfalse.

23.14.13.2.4 function invocation [func.wrap.func.inv]

R operator()(ArgTypes... args) const;

Returns:INVOKE<R>(f, std::forward<ArgTypes>(args)...) ([func.require]), гдеf -target object оф*this.

Throws: bad_function_call если!*this; в противном случае - любое исключение, созданное обернутым вызываемым объектом.

23.14.13.2.5 function target access [func.wrap.func.targ]

const type_info& target_type() const noexcept;

Returns: Если*this есть цель типаT, typeid(T); в противном случаеtypeid(void).

template<class T> T* target() noexcept; template<class T> const T* target() const noexcept;

Returns: Еслиtarget_type() == typeid(T) указатель на сохраненную функцию target; в противном случае - нулевой указатель.

23.14.13.2.6 null pointer comparison functions [func.wrap.func.nullptr]

template <class R, class... ArgTypes> bool operator==(const function<R(ArgTypes...)>& f, nullptr_t) noexcept; template <class R, class... ArgTypes> bool operator==(nullptr_t, const function<R(ArgTypes...)>& f) noexcept;

Returns:!f.

template <class R, class... ArgTypes> bool operator!=(const function<R(ArgTypes...)>& f, nullptr_t) noexcept; template <class R, class... ArgTypes> bool operator!=(nullptr_t, const function<R(ArgTypes...)>& f) noexcept;

Returns:(bool)f.

23.14.13.2.7 specialized algorithms [func.wrap.func.alg]

template<class R, class... ArgTypes> void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>& f2) noexcept;

Effects: Как будто по:f1.swap(f2);