Namespaces
Variants

    std::function_ref::function_ref

    De es.cppreference.net
     
    C++
    Soporte del compilador
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de utilidades
    Soporte del lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de la biblioteca (C++20)
    Utilidades de programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Soporte de corrutinas (C++20)
    Soporte de contratos (C++26)
    Comparación de tres vías
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilidades generales
    Operadores relacionales (obsoleto en C++20)
     
    Objetos función
    Invocación de funciones
    (C++17)(C++23)
    Objeto función identidad
    (C++20)
    Envoltorios de operadores transparentes
    (C++14)
    (C++14)
    (C++14)
    (C++14)  
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)

    Enlazadores y adaptadores antiguos
    (hasta C++17*)
    (hasta C++17*)
    (hasta C++17*)
    (hasta C++17*)
    (hasta C++17*)  
    (hasta C++17*)
    (hasta C++17*)(hasta C++17*)(hasta C++17*)(hasta C++17*)
    (hasta C++20*)
    (hasta C++20*)
    (hasta C++17*)(hasta C++17*)
    (hasta C++17*)(hasta C++17*)

    (hasta C++17*)
    (hasta C++17*)(hasta C++17*)(hasta C++17*)(hasta C++17*)
    (hasta C++20*)
    (hasta C++20*)
     
    std::function_ref
     
    template< class F >
function_ref( F* f ) noexcept;
    		(1) (desde C++26) 
    template< class F >
function_ref( F&& f ) noexcept;
    		(2) (desde C++26) 
    template< auto f >
function_ref( std::nontype_t<f> ) noexcept;
    		(3) (desde C++26) 
    template< auto f, class U >
function_ref( std::nontype_t<f>, U&& obj ) noexcept;
    		(4) (desde C++26) 
    template< auto f, class T >
function_ref( std::nontype_t<f>, /*cv*/ T* obj ) noexcept;
    		(5) (desde C++26) 
    function_ref( const function_ref& other ) = default;
    		(6) (desde C++26)

    Crea un nuevo std::function_ref.

    1) Inicializa bound-entity con f, y thunk-ptr con la dirección de una función thunk. El comportamiento no está definido si f es un puntero nulo.
    • Esta sobrecarga participa en la resolución de sobrecarga solo si tanto std::is_function_v<F> como /*is-invocable-using*/<F> son true.
    2) Inicializa bound-entity con std::addressof(f), y thunk-ptr con la dirección de una función thunk.
    • Sea T igual a std::remove_reference_t<F>. Esta sobrecarga participa en la resolución de sobrecarga solo si :
      • std::remove_cvref_t<F> no es del mismo tipo que function_ref,
      • std::is_member_pointer_v<T> es false, y
      • /*is-invocable-using*/</*cv*/ T&> es true.
    3) Inicializa bound-entity con un puntero a un objeto no especificado o un valor de puntero nulo, y thunk-ptr con la dirección de una función thunk.
    • Sea F igual a decltype(f). Esta sobrecarga participa en la resolución de sobrecarga solo si /*is-invocable-using*/<F> es true.
    • El programa está mal formado si f != nullptr es false cuando std::is_pointer_v<F> || std::is_member_pointer_v<F> es true.
    4) Inicializa bound-entity con std::addressof(obj), y thunk-ptr con la dirección de una función thunk.
    • Sea T igual a std::remove_reference_t<U> y F igual a decltype(f). Esta sobrecarga participa en la resolución de sobrecarga solo si :
      • std::is_rvalue_reference_v<U&&> es false, y
      • /*is-invocable-using*/<F, /*cv*/ T&> es true.
    • El programa está mal formado si f != nullptr es false cuando std::is_pointer_v<F> || std::is_member_pointer_v<F> es true.
    5) Inicializa bound-entity con obj, y thunk-ptr con la dirección de una función thunk. El comportamiento no está definido si obj es un puntero nulo cuando std::is_member_pointer_v<F> es true.
    • Sea F igual a decltype(f). Esta sobrecarga participa en la resolución de sobrecarga solo si /*is-invocable-using*/<F, /*cv*/ T*> es true.
    • El programa está mal formado si f != nullptr es false cuando std::is_pointer_v<F> || std::is_member_pointer_v<F> es true.
    6) El constructor de copia por defecto copia el bound-entity y thunk-ptr de other.

    La dirección de una función thunk se usa para inicializar thunk-ptr de manera que una llamada a thunk(bound-entity, call-args...) sea equivalente a expresión a:

    Sobrecargas Equivalencia de expresión
    (1,3) std::invoke_r<R>(f, call-args...)
    (2) std::invoke_r<R>(static_cast<cvT&>(f), call-args...)
    (4) std::invoke_r<R>(f, static_cast<cvT&>(obj), call-args...)
    (5) std::invoke_r<R>(f, obj, call-args...)

    /*is-invocable-using*/<T...> es true si y solo si:

    • std::is_nothrow_invocable_r_v<R, T..., Args...> es true si noex es true, o
    • std::is_invocable_r_v<R, T..., Args...> es true

    Parámetros

    other - otro function_ref desde el cual copiar
    f - una función u objeto Callable a envolver
    obj - un objeto o puntero a vincular

    Ejemplo

    Esta sección está incompleta
    Motivo: sin ejemplo

    Véase también

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