Namespaces
Variants

std:: function

From cppreference.net
C++
Utilities library
Function objects
Function invocation
(C++17) (C++23)
Identity function object
(C++20)
Old binders and adaptors
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
( until C++17* ) ( until C++17* )
( until C++17* ) ( until C++17* )

( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
std::function
Определено в заголовке <functional>
template < class >
class function ; /* undefined */
(начиная с C++11)
template < class R, class ... Args >
class function < R ( Args... ) > ;
(начиная с C++11)

Шаблон класса std::function является универсальным полиморфным обёрткой для функций. Экземпляры std::function могут хранить, копировать и вызывать любые CopyConstructible Callable цели -- функции (через указатели на них), лямбда-выражения , выражения привязки , или другие функциональные объекты, а также указатели на методы класса и указатели на члены данных.

Сохраненный вызываемый объект называется целевым объектом (target) std::function . Если std::function не содержит целевого объекта, он называется пустым (empty). Вызов целевого объекта у пустого std::function приводит к выбрасыванию исключения std::bad_function_call .

std::function удовлетворяет требованиям CopyConstructible и CopyAssignable .

Содержание

Типы членов

Тип Определение
result_type R
argument_type
(устарело в C++17) (удалено в C++20) 		T если sizeof... ( Args ) == 1 и T является первым и единственным типом в Args...
first_argument_type
(устарело в C++17) (удалено в C++20) 		T1 если sizeof... ( Args ) == 2 и T1 является первым из двух типов в Args...
second_argument_type
(устарело в C++17) (удалено в C++20) 		T2 если sizeof... ( Args ) == 2 и T2 является вторым из двух типов в Args...

Функции-члены

создает новый экземпляр std::function
(публичная функция-член)
уничтожает экземпляр std::function
(публичная функция-член)
присваивает новую цель
(публичная функция-член)
обменивает содержимое
(публичная функция-член)
(удалено в C++17)
присваивает новую цель
(публичная функция-член)
проверяет, содержит ли цель
(публичная функция-член)
вызывает цель
(публичная функция-член)
Доступ к цели
получает typeid сохраненной цели
(публичная функция-член)
получает указатель на сохраненную цель
(публичная функция-член)

Функции, не являющиеся членами класса

(C++11)
специализирует алгоритм std::swap
(шаблон функции)
(удалено в C++20)
сравнивает std::function с nullptr
(шаблон функции)

Вспомогательные классы

(C++11) (until C++17)
специализирует std::uses_allocator type trait
(специализация шаблона класса)

Руководства по выводу (начиная с C++17)

Примечания

Следует проявлять осторожность при инициализации std::function , тип результата которого является ссылкой, из лямбда-выражения без завершающего типа возврата. Из-за особенностей работы вывода типа auto , такое лямбда-выражение всегда возвращает prvalue. Следовательно, результирующая ссылка обычно будет привязываться к временному объекту, время жизни которого заканчивается, когда возвращается std::function::operator() .

(до C++23)

Если std::function , возвращающий ссылку, инициализируется из функции или функционального объекта, возвращающего prvalue (включая лямбда-выражение без завершающего типа возврата), программа является некорректной, поскольку запрещено привязывать возвращаемую ссылку к временному объекту.

(начиная с C++23) 
std::function<const int&()> F([] { return 42; }); // Ошибка начиная с C++23: невозможно привязать
                                                  // возвращаемую ссылку к временному объекту
int x = F(); // Неопределённое поведение до C++23: результат F() является висячей ссылкой
std::function<int&()> G([]() -> int& { static int i{0x2A}; return i; }); // Корректно
std::function<const int&()> H([i{052}] -> const int& { return i; }); // Корректно

Пример

Запустить этот код 
#include <functional>
#include <iostream>
struct Foo
{
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout << num_ + i << '\n'; }
    int num_;
};
void print_num(int i)
{
    std::cout << i << '\n';
}
struct PrintNum
{
    void operator()(int i) const
    {
        std::cout << i << '\n';
    }
};
int main()
{
    // сохранение свободной функции
    std::function<void(int)> f_display = print_num;
    f_display(-9);
    // сохранение лямбда-выражения
    std::function<void()> f_display_42 = []() { print_num(42); };
    f_display_42();
    // сохранение результата вызова std::bind
    std::function<void()> f_display_31337 = std::bind(print_num, 31337);
    f_display_31337();
    // сохранение вызова метода класса
    std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
    const Foo foo(314159);
    f_add_display(foo, 1);
    f_add_display(314159, 1);
    // сохранение вызова метода доступа к данным
    std::function<int(Foo const&)> f_num = &Foo::num_;
    std::cout << "num_: " << f_num(foo) << '\n';
    // сохранение вызова метода класса и объекта
    using std::placeholders::_1;
    std::function<void(int)> f_add_display2 = std::bind(&Foo::print_add, foo, _1);
    f_add_display2(2);
    // сохранение вызова метода класса и указателя на объект
    std::function<void(int)> f_add_display3 = std::bind(&Foo::print_add, &foo, _1);
    f_add_display3(3);
    // сохранение вызова функционального объекта
    std::function<void(int)> f_display_obj = PrintNum();
    f_display_obj(18);
    auto factorial = [](int n)
    {
        // сохранение лямбда-объекта для эмуляции "рекурсивной лямбды"; учитывайте дополнительные накладные расходы
        std::function<int(int)> fac = [&](int n) { return (n < 2) ? 1 : n * fac(n - 1); };
        // обратите внимание, что "auto fac = [&](int n) {...};" не работает в рекурсивных вызовах
        return fac(n);
    };
    for (int i{5}; i != 8; ++i)
        std::cout << i << "! = " << factorial(i) << ";  ";
    std::cout << '\n';
}

Возможный вывод: 

-9
42
31337
314160
314160
num_: 314159
314161
314162
18
5! = 120;  6! = 720;  7! = 5040;

Смотрите также

(C++23)
перемещаемая обёртка любого вызываемого объекта, поддерживающего квалификаторы в заданной сигнатуре вызова
(шаблон класса)
(C++26)
копируемая обёртка любого копируемого вызываемого объекта, поддерживающего квалификаторы в заданной сигнатуре вызова
(шаблон класса)
(C++26)
невладеющая обёртка любого вызываемого объекта
(шаблон класса)
(C++11)
исключение, выбрасываемое при вызове пустого std::function
(класс)
(C++11)
создаёт функциональный объект из указателя на член
(шаблон функции)
typeid запрашивает информацию о типе, возвращая объект std::type_info представляющий тип