Namespaces
Variants

    std::copyable_function::copyable_function

    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)

    Binders 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::copyable_function
     
    copyable_function() noexcept;
    		(1) (desde C++26) 
    copyable_function( std::nullptr_t ) noexcept;
    		(2) (desde C++26) 
    copyable_function( const copyable_function& other );
    		(3) (desde C++26) 
    copyable_function( copyable_function&& other ) noexcept;
    		(4) (desde C++26) 
    template< class F > 
copyable_function( F&& f );
    		(5) (desde C++26) 
    template< class T, class... CArgs > 
explicit copyable_function( std::in_place_type_t<T>, CArgs&&... args );
    		(6) (desde C++26) 
    template< class T, class U, class... CArgs > 
explicit copyable_function( std::in_place_type_t<T>,
                            std::initializer_list<U> il, CArgs&&... args );
    		(7) (desde C++26)

    Crea un nuevo std::copyable_function.

    1,2) El constructor por defecto y el constructor que toma nullptr construyen un std::copyable_function vacío.
    3) El constructor de copia construye un std::copyable_function cuyo destino es una copia del destino de other. De lo contrario, construye un std::copyable_function vacío si other está vacío.
    4) El constructor de movimiento construye un std::copyable_function cuyo destino es el de other. other está en un estado válido pero no especificado después de la construcción por movimiento.
    5) Sea VT igual a std::decay_t<F>. Si f es un puntero a función nulo, un puntero a miembro nulo, o un std::copyable_function vacío (puede ser cualquier otra especialización), entonces construye un std::copyable_function vacío. De lo contrario, construye un std::copyable_function cuyo destino es de tipo VT e inicializado directo-no-lista con std::forward<F>(f).
    • Esta sobrecarga solo participa en la resolución de sobrecarga si VT no es ni igual a copyable_function ni una especialización de std::in_place_type_t, y /*is-callable-from*/<VT> (ver más abajo) es true.
    • El programa está mal formado si std::is_constructible_v<VT, F> o std::is_copy_constructible_v<VT> no es true.
    6) Sea VT igual a std::decay_t<T>. Construye un std::copyable_function cuyo destino es de tipo VT e inicializado directo-no-lista con std::forward<CArgs>(args)....
    • Esta sobrecarga solo participa en la resolución de sobrecarga si tanto std::is_constructible_v<VT, CArgs...> como /*is-callable-from*/<VT> (ver más abajo) son true.
    • El programa está mal formado si VT no es del mismo tipo que T o std::is_copy_constructible_v<VT> no es true.
    7) Sea VT igual a std::decay_t<T>. Construye un std::copyable_function cuyo destino es de tipo VT e inicializado directo-no-lista con il, std::forward<CArgs>(args)....
    • Esta sobrecarga solo participa en la resolución de sobrecarga si tanto std::is_constructible_v<VT, std::initializer_list<U>&, CArgs...> como /*is-callable-from*/<VT> (ver más abajo) son true.
    • El programa está mal formado si VT no es del mismo tipo que T o std::is_copy_constructible_v<VT> no es true.

    Para los constructores (5-7), el comportamiento no está definido a menos que VT satisfaga ambos requisitos Destructible y CopyConstructible.

    La constante /*is-callable-from*/<VT> depende de cv, ref, y noex en el parámetro de plantilla de std::copyable_function como se indica a continuación:

    cv ref noexcept(noex) /*is-callable-from*/<VT>
    noexcept(false) std::is_invocable_r_v<R, VT, Args...> && std::is_invocable_r_v<R, VT&, Args...>
    noexcept(true) std::is_nothrow_invocable_r_v<R, VT, Args...> && std::is_nothrow_invocable_r_v<R, VT&, Args...>
    const noexcept(false) std::is_invocable_r_v<R, const VT, Args...> && std::is_invocable_r_v<R, const VT&, Args...>
    const noexcept(true) std::is_nothrow_invocable_r_v<R, const VT, Args...> && std::is_nothrow_invocable_r_v<R, const VT&, Args...>
    & noexcept(false) std::is_invocable_r_v<R, VT&, Args...>
    & noexcept(true) std::is_nothrow_invocable_r_v<R, VT&, Args...>
    const & noexcept(false) std::is_invocable_r_v<R, const VT&, Args...>
    const & noexcept(true) std::is_nothrow_invocable_r_v<R, const VT&, Args...>
    && noexcept(false) std::is_invocable_r_v<R, VT, Args...>
    && noexcept(true) std::is_nothrow_invocable_r_v<R, VT, Args...>
    const && noexcept(false) std::is_invocable_r_v<R, const VT, Args...>
    const && noexcept(true) std::is_nothrow_invocable_r_v<R, const VT, Args...>

    Parámetros

    other - otro std::copyable_function desde el cual copiar o mover
    f - una función u objeto Callable a encapsular
    args - argumentos para construir el objeto destino
    il - std::initializer_list para construir el objeto destino

    Excepciones

    3) Puede lanzar std::bad_alloc en caso de fallo de asignación o propagar la excepción lanzada por la inicialización del objetivo.
    5-7) Puede lanzar std::bad_alloc en caso de fallo de asignación o propagar la excepción lanzada por la inicialización del objetivo. No se lanza ninguna excepción si VT es un tipo de puntero a función o una especialización de std::reference_wrapper .

    Ejemplo

    Esta sección está incompleta
    Razón: sin ejemplo

    Véase también

    		construye una nueva instancia de std::function
    (función miembro pública de std::function<R(Args...)> )
    		construye un nuevo objeto std::move_only_function
    (función miembro pública de std::move_only_function )