Namespaces
Variants

std::function<R(Args...)>:: 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
function ( ) noexcept ;
(1) (desde C++11)
function ( std:: nullptr_t ) noexcept ;
(2) (desde C++11)
function ( const function & other ) ;
(3) (desde C++11)
(4)
function ( function && other ) ;
(desde C++11)
(hasta C++20)
function ( function && other ) noexcept ;
(desde C++20)
template < class F >
function ( F && f ) ;
(5) (desde C++11)
template < class Alloc >
function ( std:: allocator_arg_t , const Alloc & alloc ) noexcept ;
(6) (desde C++11)
(eliminado en C++17)
template < class Alloc >

function ( std:: allocator_arg_t , const Alloc & alloc,

std:: nullptr_t ) noexcept ;
(7) (desde C++11)
(eliminado en C++17)
template < class Alloc >

function ( std:: allocator_arg_t , const Alloc & alloc,

const function & other ) ;
(8) (desde C++11)
(eliminado en C++17)
template < class Alloc >

function ( std:: allocator_arg_t , const Alloc & alloc,

function && other ) ;
(9) (desde C++11)
(eliminado en C++17)
template < class F, class Alloc >
function ( std:: allocator_arg_t , const Alloc & alloc, F f ) ;
(10) (desde C++11)
(eliminado en C++17)

Construye un std::function a partir de diversas fuentes.

1,2) Crea un vacío std::function .
3) Copia el target de other al target de * this .
Si other está vacío, * this también estará vacío inmediatamente después de la llamada.
4) Mueve el objetivo de other al objetivo de * this .
Si other está vacío, * this también estará vacío inmediatamente después de la llamada.
other se encuentra en un estado válido pero no especificado justo después de la llamada.
5) Inicializa el destino con std:: forward < F > ( f ) . El destino es de tipo std:: decay < F > :: type .
Si f es un puntero nulo a función, un puntero nulo a miembro, o un valor vacío de alguna std::function especialización, * this estará vacío inmediatamente después de la llamada.
Esta sobrecarga participa en la resolución de sobrecarga solo si se cumplen todas las siguientes condiciones:
(desde C++23)
  • Un valor-l de tipo std:: decay < F > :: type es invocable para tipos de argumentos Args... y tipo de retorno R .

Si std:: is_copy_constructible_v < std:: decay_t < F >> o std:: is_constructible_v < std:: decay_t < F > , F > es false , el programa está mal formado.

(desde C++23)
Si F no es CopyConstructible , el comportamiento es indefinido.
6-10) Lo mismo que (1-5) excepto que alloc se utiliza para asignar memoria para cualquier estructura de datos interna que std::function pueda utilizar.

Cuando el objetivo es un puntero a función o un std::reference_wrapper , se garantiza la optimización de objetos pequeños, es decir, estos objetivos siempre se almacenan directamente dentro del objeto std::function , sin que se produzca ninguna asignación dinámica. Otros objetos grandes pueden construirse en almacenamiento asignado dinámicamente y ser accedidos por el objeto std::function a través de un puntero.

Contenidos

Parámetros

other - el objeto función utilizado para inicializar * this
f - un objeto invocable utilizado para inicializar * this
alloc - un Allocator utilizado para la asignación interna de memoria
Requisitos de tipo
-
Alloc debe cumplir con los requisitos de Allocator .

Excepciones

3,8,9) No lanza excepciones si other tiene como objetivo un puntero a función o un std::reference_wrapper , de lo contrario puede lanzar std::bad_alloc o cualquier excepción lanzada por el constructor utilizado para copiar o mover el objeto invocable almacenado.
4) No lanza excepciones si other tiene como destino un puntero a función o un std::reference_wrapper , de lo contrario puede lanzar std::bad_alloc o cualquier excepción lanzada por el constructor utilizado para copiar o mover el objeto invocable almacenado.
(until C++20)
5,10) No lanza excepciones si f es un puntero a función o un std::reference_wrapper , de lo contrario puede lanzar std::bad_alloc o cualquier excepción lanzada por el constructor de copia del objeto invocable almacenado.

Notas

std::function tenía un soporte de asignadores mal especificado e implementado de manera inconsistente. Algunas implementaciones no proporcionan las sobrecargas ( 6-10 ) en absoluto, algunas proporcionan las sobrecargas pero ignoran el argumento del asignador suministrado, y algunas proporcionan las sobrecargas y utilizan el asignador suministrado para la construcción pero no cuando el std::function es reasignado. Como resultado, el soporte de asignadores fue eliminado en C++17.

Ejemplo

Ejecutar este código 
#include <functional>
#include <iostream>
#include <utility>
void print_num(int i) { std::cout << "print_num(" << i << ")\n"; }
int main()
{
    std::function<void(int)> func1; // (1) constructor vacío
    try
    {
        func1(333 << 1);
    {
    catch (const std::bad_function_call& ex)
    {
        std::cout << "1) " << ex.what() << '\n';
    }
    std::function<void(int)> func2{nullptr}; // (2) constructor vacío
    try
    {
        func1(222 * 3);
    {
    catch (const std::bad_function_call& ex)
    {
        std::cout << "2) " << ex.what() << '\n';
    }
    func1 = print_num; // inicializa func1 usando operador de asignación
    std::function<void(int)> func3{func1}; // (3) constructor de copia
    func3(33);
    std::function<void(int)> func4{std::move(func3)}; // (4) constructor de movimiento,
                                                      // func3 en estado no especificado
    func4(44);
    std::function<void(int)> func5{print_num}; // (5) constructor con función
    func5(55);
    // (5) constructor con lambda
    std::function<void(int)> func6([](int i) { std::cout << "lambda(" << i << ")\n"; });
    func6(66);
}

Salida posible: 

1) bad_function_call
2) bad_function_call
print_num(33)
print_num(44)
print_num(55)
lambda(66)

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2132 C++11 las sobrecargas ( 5,10 ) podrían ser ambiguas restringidas
LWG 2774 C++11 ( 5,10 ) realizaba un movimiento adicional eliminado

Véase también

construye un nuevo objeto std::move_only_function
(función miembro pública de std::move_only_function )